From 89d3c89884a31672fef35663b8bc2ccf8db0367a Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Mon, 20 Jan 2025 14:10:40 -0500 Subject: [PATCH 01/12] clang2il.go: Check for desugared types (support clang-15+) * Closes #116 --- cmd/genbindings/clang2il.go | 149 ++++++++++++++++-- cmd/genbindings/clang2il_test.go | 14 +- cmd/genbindings/config-libraries.go | 4 - cmd/genbindings/transformchildclasses_test.go | 6 +- cmd/genbindings/transformtypedefs_test.go | 4 +- cmd/genbindings/util.go | 4 +- 6 files changed, 151 insertions(+), 30 deletions(-) diff --git a/cmd/genbindings/clang2il.go b/cmd/genbindings/clang2il.go index 71987021cb..66490a4350 100644 --- a/cmd/genbindings/clang2il.go +++ b/cmd/genbindings/clang2il.go @@ -11,6 +11,18 @@ import ( var ( ErrTooComplex = errors.New("Type declaration is too complex to parse") ErrNoContent = errors.New("There's no content to include") + + // Qt container types that can hold other types + qtContainers = []string{ + "QHash<", + "QList<", + "QMap<", + "QPair<", + "QQueue<", + "QSet<", + "QStack<", + "QVector<", + } ) // parseHeader parses a whole C++ header into our CppParsedHeader intermediate format. @@ -69,7 +81,8 @@ nextTopLevel: case "FileScopeAsmDecl": // ignore - case "NamespaceDecl": + case "NamespaceDecl", + "NamespaceAliasDecl": // Parse everything inside the namespace with prefix, as if it is // a whole separate file // Then copy the parsed elements back into our own file @@ -103,7 +116,7 @@ nextTopLevel: case "EnumDecl": // Child class enum - en, err := processEnum(node, addNamePrefix) + en, err := processEnum(node, addNamePrefix, VsPublic) if err != nil { panic(fmt.Errorf("processEnum: %w", err)) // A real problem } @@ -165,6 +178,48 @@ nextTopLevel: return &ret, nil // done } +// shouldPreferQualType returns true if we should use the qualType instead of +// the desugared type based on certain type patterns +func shouldPreferQualType(qualType string) bool { + if strings.Contains(qualType, "intptr") || strings.Contains(qualType, "_t") || + strings.HasPrefix(qualType, "uint") || strings.Contains(qualType, "ushort") || + strings.Contains(qualType, "quint") || strings.Contains(qualType, "qint") || + strings.Contains(qualType, "qptrdiff") || strings.HasPrefix(qualType, "qsize") || + strings.HasPrefix(qualType, "QList<") || strings.HasPrefix(qualType, "QPair<") || + strings.HasPrefix(qualType, "QIntegerForSizeof<") { + return true + } + return false +} + +// getPreferredType returns either the desugared type or qual type based on our rules +func getPreferredType(node interface{}) string { + if node == nil { + return "" + } + + nodeMap, ok := node.(map[string]interface{}) + if !ok { + return "" + } + + var desugared, qualType string + if d, ok := nodeMap["desugaredQualType"].(string); ok { + desugared = d + } + if q, ok := nodeMap["qualType"].(string); ok { + qualType = q + } + + if qualType != "" && shouldPreferQualType(qualType) { + return qualType + } + if desugared != "" { + return desugared + } + return qualType +} + // processTypedef parses a single C++ typedef into our intermediate format. func processTypedef(node map[string]interface{}, addNamePrefix string) (CppTypedef, error) { // Must have a name @@ -174,7 +229,8 @@ func processTypedef(node map[string]interface{}, addNamePrefix string) (CppTyped } if typ, ok := node["type"].(map[string]interface{}); ok { - if qualType, ok := typ["qualType"].(string); ok { + qualType := getPreferredType(typ) + if qualType != "" { return CppTypedef{ Alias: addNamePrefix + nodename, UnderlyingType: parseSingleTypeString(qualType), @@ -264,7 +320,8 @@ func processClassType(node map[string]interface{}, addNamePrefix string) (CppCla } if typ, ok := base["type"].(map[string]interface{}); ok { - if qualType, ok := typ["qualType"].(string); ok { + qualType := getPreferredType(typ) + if qualType != "" { ret.DirectInherits = append(ret.DirectInherits, qualType) } } @@ -355,7 +412,7 @@ nextMethod: continue // Skip private, ALLOW protected } - en, err := processEnum(node, nodename+"::") + en, err := processEnum(node, nodename+"::", visibility) if err != nil { panic(fmt.Errorf("processEnum: %w", err)) // A real problem } @@ -379,7 +436,7 @@ nextMethod: } var mm CppMethod - err := parseMethod(node, &mm) + err := parseMethod(node, &mm, ret.ClassName) if err != nil { if errors.Is(err, ErrTooComplex) { log.Printf("Skipping ctor with complex type") @@ -450,7 +507,7 @@ nextMethod: var mm CppMethod mm.MethodName = methodName - err := parseMethod(node, &mm) + err := parseMethod(node, &mm, ret.ClassName) if err != nil { if errors.Is(err, ErrTooComplex) { log.Printf("Skipping method %q with complex type", mm.MethodName) @@ -536,14 +593,16 @@ func isPrivateSignal(method *CppMethod) (int, bool) { } // processEnum parses a Clang enum into our CppEnum intermediate format. -func processEnum(node map[string]interface{}, addNamePrefix string) (CppEnum, error) { +func processEnum(node map[string]interface{}, addNamePrefix string, visibility visibilityState) (CppEnum, error) { var ret CppEnum + ret.IsProtected = (visibility == VsProtected) // Underlying type ret.UnderlyingType = parseSingleTypeString("int") if nodefut, ok := node["fixedUnderlyingType"].(map[string]interface{}); ok { - if nodequal, ok := nodefut["qualType"].(string); ok { - ret.UnderlyingType = parseSingleTypeString(nodequal) + qualType := getPreferredType(nodefut) + if qualType != "" { + ret.UnderlyingType = parseSingleTypeString(qualType) } } @@ -679,10 +738,11 @@ nextEnumEntry: } // parseMethod parses a Clang method into our CppMethod intermediate format. -func parseMethod(node map[string]interface{}, mm *CppMethod) error { +func parseMethod(node map[string]interface{}, mm *CppMethod, className string) error { if typobj, ok := node["type"].(map[string]interface{}); ok { - if qualType, ok := typobj["qualType"].(string); ok { + qualType := getPreferredType(typobj) + if qualType != "" { // The qualType is the whole type of the method, including its parameter types // If anything here is too complicated, skip the whole method @@ -692,6 +752,71 @@ func parseMethod(node map[string]interface{}, mm *CppMethod) error { return err } + if qtVersion != "qt5" { + fullClassName := className + "::" + mm.ReturnType.ParameterType + + // Add resolution for return type if it's a typedef + if !mm.ReturnType.IsKnownEnum() { + if typedef, ok := KnownTypedefs[fullClassName]; ok { + if strings.HasPrefix(typedef.Typedef.UnderlyingType.ParameterType, "QFlags<") { + mm.ReturnType.ParameterType = fullClassName + if mm.ReturnType.QtCppOriginalType != nil { + mm.ReturnType.QtCppOriginalType.ParameterType = fullClassName + } + } + + if strings.Contains(mm.ReturnType.ParameterType, "_type") { + if mm.ReturnType.QtCppOriginalType == nil { + tmp := mm.ReturnType // copy + mm.ReturnType.QtCppOriginalType = &tmp + mm.ReturnType.QtCppOriginalType.ParameterType = fullClassName + } + mm.ReturnType.ParameterType = className + "::" + mm.ReturnType.ParameterType + } + } + } + + // Add resolution for return type if it's a struct + if _, ok := KnownClassnames[fullClassName]; ok { + mm.ReturnType.ParameterType = fullClassName + } + + // Add resolution for return type if it's an enum + if _, ok := KnownEnums[mm.ReturnType.ParameterType]; ok { + mm.ReturnType.ParameterType = resolveEnumType(mm.ReturnType.ParameterType, className, "Qt") + } + + // Add resolution for parameters if they're enums + for i := range mm.Parameters { + if !mm.Parameters[i].IsKnownEnum() { + // Check if it's a typedef and resolve to underlying type + classScoped := className + "::" + mm.Parameters[i].ParameterType + + if typedef, ok := KnownTypedefs[classScoped]; ok { + if strings.HasPrefix(typedef.Typedef.UnderlyingType.ParameterType, "QFlags<") { + mm.Parameters[i].ParameterType = typedef.Typedef.UnderlyingType.ParameterType + if mm.Parameters[i].QtCppOriginalType != nil { + mm.Parameters[i].QtCppOriginalType.ParameterType = typedef.Typedef.UnderlyingType.ParameterType + } + } + } else { + if typeDef, ok := KnownTypedefs[mm.Parameters[i].ParameterType]; ok && !strings.Contains(mm.Parameters[i].ParameterType, "::") { + if strings.HasSuffix(mm.Parameters[i].ParameterType, "Mode") || mm.Parameters[i].ParameterType == "Capabilities" { + mm.Parameters[i].ParameterType = typeDef.Typedef.UnderlyingType.ParameterType + if mm.Parameters[i].QtCppOriginalType != nil { + mm.Parameters[i].QtCppOriginalType.ParameterType = typeDef.Typedef.UnderlyingType.ParameterType + } + } + } + } + } + + // Add resolution for parameters if they're enums + if _, ok := KnownEnums[mm.Parameters[i].ParameterType]; ok { + mm.Parameters[i].ParameterType = resolveEnumType(mm.Parameters[i].ParameterType, className, "Qt") + } + } + } } } diff --git a/cmd/genbindings/clang2il_test.go b/cmd/genbindings/clang2il_test.go index 43f970498c..fa7e533578 100644 --- a/cmd/genbindings/clang2il_test.go +++ b/cmd/genbindings/clang2il_test.go @@ -14,27 +14,27 @@ func TestParseMethodTypes(t *testing.T) { } cases := []testCase{ - testCase{ + { input: "void (bool)", expectReturn: CppParameter{ParameterType: "void"}, expectParams: []CppParameter{ - CppParameter{ParameterType: "bool"}, + {ParameterType: "bool"}, }, }, - testCase{ + { input: "bool (QList>, QString)", expectReturn: CppParameter{ParameterType: "bool"}, expectParams: []CppParameter{ - CppParameter{ParameterType: "QList>"}, - CppParameter{ParameterType: "QString"}, + {ParameterType: "QList>"}, + {ParameterType: "QString"}, }, // expectErr: true, }, - testCase{ + { input: "bool (QList)", expectReturn: CppParameter{ParameterType: "bool"}, expectParams: []CppParameter{ - CppParameter{ParameterType: "QList"}, + {ParameterType: "QList"}, }, }, } diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go index b6cc5d7725..655089eaa4 100644 --- a/cmd/genbindings/config-libraries.go +++ b/cmd/genbindings/config-libraries.go @@ -215,7 +215,6 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) - // Depends on QtCore/Gui/Widgets, QPrintSupport generate( "qt-restricted-extras/qscintilla", @@ -450,7 +449,6 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) - // Qt 6 PDF generate( "qt6/pdf", @@ -465,8 +463,6 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { ClangMatchSameHeaderDefinitionOnly, ) - - // Qt 6 Charts // Depends on QtCore/Gui/Widgets generate( diff --git a/cmd/genbindings/transformchildclasses_test.go b/cmd/genbindings/transformchildclasses_test.go index 456b5facde..1656ae2170 100644 --- a/cmd/genbindings/transformchildclasses_test.go +++ b/cmd/genbindings/transformchildclasses_test.go @@ -9,17 +9,17 @@ func TestChildClassesExtract(t *testing.T) { src := CppParsedHeader{ Classes: []CppClass{ - CppClass{ + { ClassName: "Parent", ChildClassdefs: []CppClass{ - CppClass{ + { ClassName: "Parent::Child", ChildClassdefs: []CppClass{ - CppClass{ + { ClassName: "Parent::Child::Grandchild", }, }, diff --git a/cmd/genbindings/transformtypedefs_test.go b/cmd/genbindings/transformtypedefs_test.go index f9d0ef9e3c..7496c9d2d9 100644 --- a/cmd/genbindings/transformtypedefs_test.go +++ b/cmd/genbindings/transformtypedefs_test.go @@ -12,11 +12,11 @@ func TestTransformTypedefs(t *testing.T) { return CppParsedHeader{ Classes: []CppClass{ - CppClass{ + { ClassName: "QTestClass", Ctors: []CppMethod{ - CppMethod{ + { Parameters: []CppParameter{ parseSingleTypeString(typeName), }, diff --git a/cmd/genbindings/util.go b/cmd/genbindings/util.go index 07e1b072ce..8dbebd5a75 100644 --- a/cmd/genbindings/util.go +++ b/cmd/genbindings/util.go @@ -1,9 +1,9 @@ package main import ( - "strconv" "encoding/json" "log" + "strconv" "strings" ) @@ -12,7 +12,7 @@ func maybeSuffix(counter int) string { return "" } - return strconv.Itoa(counter+1) + return strconv.Itoa(counter + 1) } func titleCase(s string) string { From 57c84762e92c70ea310c9c1782f2845d11be7217 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Thu, 5 Jun 2025 23:11:13 -0400 Subject: [PATCH 02/12] transformenums.go: Initial commit --- cmd/genbindings/transformenums.go | 219 ++++++++++++++++++++++++++++++ 1 file changed, 219 insertions(+) create mode 100644 cmd/genbindings/transformenums.go diff --git a/cmd/genbindings/transformenums.go b/cmd/genbindings/transformenums.go new file mode 100644 index 0000000000..2dd3689714 --- /dev/null +++ b/cmd/genbindings/transformenums.go @@ -0,0 +1,219 @@ +package main + +import "strings" + +type EnumScopeInfo struct { + FullyQualifiedName string + ClassScope string // Empty if global/namespace scope + Namespace string // Empty if global scope +} + +// Map of enum name -> class scope -> namespace -> EnumScopeInfo +var EnumScopeRegistry = make(map[string]map[string]map[string]EnumScopeInfo) + +// getAllIncludedClasses returns all included classes and inherits, including those from parent classes +func getAllIncludedClasses(c *CppClass, seen map[string]struct{}) []string { + if seen == nil { + seen = make(map[string]struct{}) + } + + var allIncludes []string + + allIncludes = append(allIncludes, c.DirectInherits...) + allIncludes = append(allIncludes, c.IncludedClasses...) + + for _, inherit := range c.DirectInherits { + if _, ok := seen[inherit]; ok { + continue + } + seen[inherit] = struct{}{} + + if parentInfo, ok := KnownClassnames[inherit]; ok { + parentIncludes := getAllIncludedClasses(&parentInfo.Class, seen) + allIncludes = append(allIncludes, parentIncludes...) + } + } + + return allIncludes +} + +func (header *CppParsedHeader) RegisterFlags() map[string]CppFlagProperty { + if header.DetectedFlags == nil { + header.DetectedFlags = make(map[string]CppFlagProperty) + } + + for _, typedef := range header.Typedefs { + typeClass := strings.Split(typedef.Alias, `::`)[0] + + // Skip private/internal types + if strings.HasSuffix(typedef.Alias, "Private") || + strings.Contains(typeClass, "Private") { + continue + } + + // Skip protected enums + if enum, ok := KnownEnums[typedef.Alias]; ok { + if enum.Enum.IsProtected { + continue + } + } + + if strings.Contains(typedef.Alias, "::") { + flagDef := strings.Split(typedef.Alias, `::`) + if len(flagDef) <= 1 { + continue + } + + className := flagDef[0] + flagName := strings.Join(flagDef[1:], ``) + + flagProperty := CppFlagProperty{ + PropertyName: typedef.Alias, // Fully qualified name + PropertyType: CppParameter{ + ParameterType: typedef.UnderlyingType.RenderTypeCabi(), + }, + } + + // Register both forms in DetectedFlags + header.DetectedFlags[typedef.Alias] = flagProperty // Full name + header.DetectedFlags[flagName] = flagProperty // Short name + + if _, ok := EnumScopeRegistry[flagName]; !ok { + EnumScopeRegistry[flagName] = make(map[string]map[string]EnumScopeInfo) + } + if _, ok := EnumScopeRegistry[flagName][className]; !ok { + EnumScopeRegistry[flagName][className] = make(map[string]EnumScopeInfo) + } + + EnumScopeRegistry[flagName][className][""] = EnumScopeInfo{ + FullyQualifiedName: typedef.Alias, + ClassScope: className, + Namespace: "", // Flags are always class-scoped + } + } + } + return header.DetectedFlags +} + +// Helper function to resolve any enum types +func resolveEnumType(enumName string, currentClass string, currentNamespace string) string { + scopeMap, exists := EnumScopeRegistry[enumName] + if !exists { + return enumName // Can't resolve + } + + // Current class scope + if currentClass != "" { + if classMap, ok := scopeMap[currentClass]; ok { + expectedName := currentClass + "::" + enumName + for _, info := range classMap { + if info.FullyQualifiedName == expectedName { + return info.FullyQualifiedName + } + } + } + + // Parent class scopes + if classInfo, ok := KnownClassnames[currentClass]; ok { + for _, parent := range classInfo.Class.DirectInheritClassInfo() { + if classMap, ok := scopeMap[parent.Class.ClassName]; ok { + for _, info := range classMap { + return info.FullyQualifiedName + } + } + } + } + } + + // Current namespace scope + if currentNamespace != "" { + if classMap, ok := scopeMap[currentNamespace]; ok { + for _, info := range classMap { + if info.ClassScope == currentNamespace { + return info.FullyQualifiedName + } + } + } + } + + // Included classes + if classInfo, ok := KnownClassnames[currentClass]; ok { + seen := map[string]struct{}{} + classInfo.Class.IncludedClasses = getAllIncludedClasses(&classInfo.Class, seen) + + for _, includedClass := range classInfo.Class.IncludedClasses { + expectedName := includedClass + "::" + enumName + if classMap, ok := scopeMap[includedClass]; ok { + for _, info := range classMap { + if info.FullyQualifiedName == expectedName { + return info.FullyQualifiedName + } + } + } + } + } + + return enumName // No match found +} + +func (method *CppMethod) resolveMethodEnumTypes(className string, namespace string) { + // Resolve return type + if method.ReturnType.IsKnownEnum() { + method.ReturnType.ParameterType = resolveEnumType(method.ReturnType.ParameterType, className, namespace) + } else { + // Check if it's a container with an enum inside + for _, container := range qtContainers { + if strings.HasPrefix(method.ReturnType.ParameterType, container) { + openPos := strings.Index(method.ReturnType.ParameterType, "<") + closePos := strings.LastIndex(method.ReturnType.ParameterType, ">") + if openPos != -1 && closePos != -1 { + innerType := method.ReturnType.ParameterType[openPos+1 : closePos] + if _, ok := KnownEnums[innerType]; ok { + resolvedInner := resolveEnumType(innerType, className, namespace) + method.ReturnType.ParameterType = container + resolvedInner + ">" + } + } + } + } + } + + // Resolve parameters + for i, param := range method.Parameters { + if param.IsKnownEnum() { + method.Parameters[i].ParameterType = resolveEnumType(param.ParameterType, className, namespace) + } else { + // Check if it's a container with an enum inside + for _, container := range qtContainers { + if strings.HasPrefix(param.ParameterType, container) { + openPos := strings.Index(param.ParameterType, "<") + closePos := strings.LastIndex(param.ParameterType, ">") + if openPos != -1 && closePos != -1 { + innerType := param.ParameterType[openPos+1 : closePos] + if _, ok := KnownEnums[innerType]; ok { + resolvedInner := resolveEnumType(innerType, className, namespace) + method.Parameters[i].ParameterType = container + resolvedInner + ">" + } + } + } + } + } + } +} + +// Resolve enum types in class ctors and methods +func astTransformEnumResolution(parsed *CppParsedHeader) { + for _, class := range parsed.Classes { + var namespace string + if strings.Contains(class.ClassName, "::") { + parts := strings.Split(class.ClassName, "::") + namespace = parts[0] + } + + for i := range class.Ctors { + class.Ctors[i].resolveMethodEnumTypes(class.ClassName, namespace) + } + for i := range class.Methods { + class.Methods[i].resolveMethodEnumTypes(class.ClassName, namespace) + } + } +} From ea80e494438f528f2f60ef80c5fa7060af2b9549 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Thu, 5 Jun 2025 23:23:28 -0400 Subject: [PATCH 03/12] intermediate.go: Add helper methods and struct fields --- cmd/genbindings/intermediate.go | 65 +++++++++++++++++++++++---------- 1 file changed, 46 insertions(+), 19 deletions(-) diff --git a/cmd/genbindings/intermediate.go b/cmd/genbindings/intermediate.go index 0bf4f1add0..4767333cd2 100644 --- a/cmd/genbindings/intermediate.go +++ b/cmd/genbindings/intermediate.go @@ -125,6 +125,12 @@ func (p CppParameter) QListOf() (CppParameter, string, bool) { return ret, "QVector", true } + if strings.HasPrefix(p.ParameterType, "QSpan<") && strings.HasSuffix(p.ParameterType, `>`) { + ret := parseSingleTypeString(p.ParameterType[6 : len(p.ParameterType)-1]) + ret.ParameterName = p.ParameterName + "_sv" + return ret, "QSpan", true + } + return CppParameter{}, "", false } @@ -161,8 +167,13 @@ func (p CppParameter) QMapOf() (CppParameter, CppParameter, string, bool) { } func (p CppParameter) QPairOf() (CppParameter, CppParameter, bool) { - if strings.HasPrefix(p.ParameterType, `QPair<`) && strings.HasSuffix(p.ParameterType, `>`) { - interior := tokenizeMultipleParameters(p.ParameterType[6 : len(p.ParameterType)-1]) + if (strings.HasPrefix(p.ParameterType, `QPair<`) || strings.HasPrefix(p.ParameterType, `std::pair<`)) && + strings.HasSuffix(p.ParameterType, `>`) { + index := 6 // QPair< + if strings.HasPrefix(p.ParameterType, `std::pair<`) { + index = 10 // std::pair< + } + interior := tokenizeMultipleParameters(p.ParameterType[index : len(p.ParameterType)-1]) if len(interior) != 2 { panic("QPair<> has unexpected number of template arguments") } @@ -239,6 +250,11 @@ type CppProperty struct { Visibility string } +type CppFlagProperty struct { + PropertyName string + PropertyType CppParameter +} + type CppMethod struct { MethodName string // C++ method name, unless OverrideMethodName is set, in which case a nice alternative name OverrideMethodName string // C++ method name, present only if we changed the target @@ -302,7 +318,7 @@ func IsReceiverMethod(params []CppParameter, pos int) bool { } func (nm CppMethod) IsReceiverMethod() bool { - // Returns true if any of the parameters use the receiever-method pattern + // Returns true if any of the parameters use the receiver-method pattern for i := 0; i < len(nm.Parameters); i++ { if IsReceiverMethod(nm.Parameters, i) { return true @@ -385,6 +401,7 @@ type CppEnum struct { EnumName string UnderlyingType CppParameter Entries []CppEnumEntry + IsProtected bool } func (e CppEnum) ShortEnumName() string { @@ -399,14 +416,25 @@ func (e CppEnum) ShortEnumName() string { return e.EnumName } +func (e CppEnum) CabiEnumName() string { + if nameParts := strings.Split(e.EnumName, `::`); len(nameParts) > 1 { + nameParts = nameParts[1:] + return strings.Join(nameParts, ``) + } + + // No change + return e.EnumName +} + type CppClass struct { - ClassName string - Abstract bool - Ctors []CppMethod // only use the parameters - DirectInherits []string // other class names. This only includes direct inheritance - use AllInherits() to find recursive inheritance - Methods []CppMethod - Props []CppProperty - CanDelete bool + ClassName string + Abstract bool + Ctors []CppMethod // only use the parameters + DirectInherits []string // other class names. This only includes direct inheritance - use AllInherits() to find recursive inheritance + IncludedClasses []string // Classes included by this class + Methods []CppMethod + Props []CppProperty + CanDelete bool ChildTypedefs []CppTypedef ChildClassdefs []CppClass @@ -491,7 +519,7 @@ func (c *CppClass) VirtualMethods() []CppMethod { // The class info we loaded has not had all typedefs applied to it // m is copied by value. Mutate it - applyTypedefs_Method(&m) + applyTypedefs_Method(&m, cinfo.Class.ClassName) // Same with astTransformBlocklist if err := blocklist_MethodAllowed(&m); err != nil { log.Printf("Blocking method %q(%v): %s", m.MethodName, m.Parameters, err) @@ -578,7 +606,7 @@ func (c *CppClass) ProtectedMethods() []CppMethod { // The class info we loaded has not had all typedefs applied to it // m is copied by value. Mutate it - applyTypedefs_Method(&m) + applyTypedefs_Method(&m, cinfo.Class.ClassName) // Same with astTransformBlocklist if err := blocklist_MethodAllowed(&m); err != nil { log.Printf("Blocking method %q(%v): %s", m.MethodName, m.Parameters, err) @@ -611,9 +639,7 @@ func (c *CppClass) AllInheritsClassInfo() []lookupResultClass { ret = append(ret, baseClassInfo) recurseInfo := baseClassInfo.Class.AllInheritsClassInfo() - for _, childClass := range recurseInfo { - ret = append(ret, childClass) - } + ret = append(ret, recurseInfo...) } return ret @@ -646,10 +672,11 @@ type CppTypedef struct { } type CppParsedHeader struct { - Filename string - Typedefs []CppTypedef - Enums []CppEnum - Classes []CppClass + Filename string + Typedefs []CppTypedef + Enums []CppEnum + Classes []CppClass + DetectedFlags map[string]CppFlagProperty } func (c CppParsedHeader) Empty() bool { From 7aa6ecc017a1879ace2e0d432485bd53ee68458e Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Thu, 5 Jun 2025 23:24:00 -0400 Subject: [PATCH 04/12] statetracker.go: Update type registration --- cmd/genbindings/statetracker.go | 91 +++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) diff --git a/cmd/genbindings/statetracker.go b/cmd/genbindings/statetracker.go index 5a1bf8e802..ce23ec38eb 100644 --- a/cmd/genbindings/statetracker.go +++ b/cmd/genbindings/statetracker.go @@ -1,5 +1,7 @@ package main +import "strings" + type lookupResultClass struct { PackageName string Class CppClass @@ -27,14 +29,103 @@ func flushKnownTypes() { KnownEnums = make(map[string]lookupResultEnum) } +// Handle child classes recursively +func registerChildClasses(class CppClass, packageName string) { + for _, childClass := range class.ChildClassdefs { + // Register with fully qualified name + KnownClassnames[childClass.ClassName] = lookupResultClass{packageName, childClass} + + // Recursively register any nested children + registerChildClasses(childClass, packageName) + } +} + func addKnownTypes(packageName string, parsed *CppParsedHeader) { for _, c := range parsed.Classes { KnownClassnames[c.ClassName] = lookupResultClass{packageName, c /* copy */} + + // If it's a nested class, also register its local name + if strings.Contains(c.ClassName, "::") { + localName := c.ClassName[strings.Index(c.ClassName, "::")+2:] + lastName := c.ClassName[strings.LastIndex(c.ClassName, "::")+2:] + KnownClassnames[localName] = lookupResultClass{packageName, c} + KnownClassnames[lastName] = lookupResultClass{packageName, c} + } + + if qtVersion != "qt5" { + for _, td := range c.ChildTypedefs { + // Register typedef with fully qualified name + KnownTypedefs[td.Alias] = lookupResultTypedef{packageName, td /* copy */} + if strings.Contains(td.Alias, "::") { + localName := td.Alias[strings.Index(td.Alias, "::")+2:] + lastName := td.Alias[strings.LastIndex(td.Alias, "::")+2:] + KnownTypedefs[localName] = lookupResultTypedef{packageName, td} + KnownTypedefs[lastName] = lookupResultTypedef{packageName, td} + } + } + + for _, childClass := range c.ChildClassdefs { + // Register class with fully qualified name + KnownClassnames[childClass.ClassName] = lookupResultClass{packageName, childClass} + registerChildClasses(c, packageName) + } + + // Handle child enums in classes + for _, en := range c.ChildEnums { + // Register enum with fully qualified name + KnownEnums[en.EnumName] = lookupResultEnum{packageName, en} + // Register short name + KnownEnums[en.CabiEnumName()] = lookupResultEnum{packageName, en} + + // Flags version + flagsEnum := en // copy + flagsEnum.EnumName = "QFlags<" + en.EnumName + ">" + KnownEnums[flagsEnum.EnumName] = lookupResultEnum{packageName, flagsEnum} + KnownEnums[en.CabiEnumName()+"s"] = lookupResultEnum{packageName, flagsEnum} + } + } } + for _, td := range parsed.Typedefs { KnownTypedefs[td.Alias] = lookupResultTypedef{packageName, td /* copy */} } + for _, en := range parsed.Enums { KnownEnums[en.EnumName] = lookupResultEnum{packageName, en /* copy */} + + if qtVersion != "qt5" { + // Register short name if it's a scoped enum + if strings.Contains(en.EnumName, "::") { + shortName := en.CabiEnumName() + KnownEnums[shortName] = lookupResultEnum{packageName, en} + } + + // Flags version + flagsEnum := en // copy + flagsEnum.EnumName = "QFlags<" + en.EnumName + ">" + KnownEnums[flagsEnum.EnumName] = lookupResultEnum{packageName, flagsEnum} + if strings.Contains(en.EnumName, "::") { + KnownEnums[en.CabiEnumName()+"s"] = lookupResultEnum{packageName, flagsEnum} + } + } + } + + if qtVersion != "qt5" { + // Register detected flags + for flagName, flagInfo := range parsed.DetectedFlags { + // Create flag enum entry + flagEnum := CppEnum{ + EnumName: flagInfo.PropertyName, + UnderlyingType: flagInfo.PropertyType, + } + + // Register with fully qualified name + KnownEnums[flagInfo.PropertyName] = lookupResultEnum{packageName, flagEnum} + + // Register with short name + if strings.Contains(flagInfo.PropertyName, "::") { + KnownEnums[flagName] = lookupResultEnum{packageName, flagEnum} + } + } } } From 84a066cfd5fb1d3804224eaaac70baad44bace6c Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Thu, 5 Jun 2025 23:24:48 -0400 Subject: [PATCH 05/12] config-libraries.go, main.go: Refactor modules for multi-pass structure and proper type resolution --- cmd/genbindings/config-libraries.go | 900 ++++++++++++++-------------- cmd/genbindings/main.go | 158 ++++- 2 files changed, 586 insertions(+), 472 deletions(-) diff --git a/cmd/genbindings/config-libraries.go b/cmd/genbindings/config-libraries.go index 655089eaa4..1a77d4a582 100644 --- a/cmd/genbindings/config-libraries.go +++ b/cmd/genbindings/config-libraries.go @@ -5,6 +5,8 @@ import ( "strings" ) +var qtVersion string + func ProcessLibraries(clangBin, outDir, extraLibsDir string) { AllowAllHeaders := func(string) bool { return true } @@ -19,475 +21,453 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) { } } + // Define our module configuration + type moduleConfig struct { + path string + dirs []string + allowHeader func(string) bool + cflags string + clangMatcher ClangMatcher + } + flushKnownTypes() InsertTypedefs(false) - generate( - "qt", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtCore", - "/usr/include/x86_64-linux-gnu/qt5/QtGui", - "/usr/include/x86_64-linux-gnu/qt5/QtWidgets", - }, - func(fullpath string) bool { - // Block cbor and generate it separately - fname := filepath.Base(fullpath) - if strings.HasPrefix(fname, "qcbor") { - return false - } - - return Widgets_AllowHeader(fullpath) - }, - clangBin, - pkgConfigCflags("Qt5Widgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - generate( - "qt/cbor", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtCore", - }, - func(fullpath string) bool { - // Only include the same json, xml, cbor files excluded above - fname := filepath.Base(fullpath) - return strings.HasPrefix(fname, "qcbor") - }, - clangBin, - pkgConfigCflags("Qt5Core"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - generate( - "qt/printsupport", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtPrintSupport", - }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5PrintSupport"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - generate( - "qt/svg", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtSvg", - }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5Svg"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 5 Network (1/3) - - generate( - "qt/network", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtNetwork", - }, - ExceptHeaders("qdtls.h", "qsctpserver.h", "qsctpsocket.h"), - clangBin, - pkgConfigCflags("Qt5Network"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 5 Network (2/3) - - generate( - "qt/network/sctp", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtNetwork", - }, - OnlyHeaders("qsctpserver.h", "qsctpsocket.h"), - clangBin, - pkgConfigCflags("Qt5Network"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 5 Network (3/3) - split out DTLS into subpackage because macOS Brew is - // compiled with it disabled - // There are still some extra functions to move out from qsslconfiguration.h - // @ref https://github.com/mappu/miqt/issues/151 - - generate( - "qt/network/dtls", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtNetwork", - }, - OnlyHeaders("qdtls.h"), - clangBin, - pkgConfigCflags("Qt5Network"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - generate( - "qt/multimedia", - []string{ - // Theoretically, QtMultimediaWidgets and QtMultimedia are different - // packages, but QtMultimedia qcamera.h has a dependency on qvideowidget. - // Bind them together since our base /qt/ package is Widgets anyway. - "/usr/include/x86_64-linux-gnu/qt5/QtMultimedia", - "/usr/include/x86_64-linux-gnu/qt5/QtMultimediaWidgets", + // Qt 5 modules + modules5 := []moduleConfig{ + { + path: "qt", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtCore", + "/usr/include/x86_64-linux-gnu/qt5/QtGui", + "/usr/include/x86_64-linux-gnu/qt5/QtWidgets", + }, + allowHeader: func(fullpath string) bool { + // Block cbor and generate it separately + fname := filepath.Base(fullpath) + if strings.HasPrefix(fname, "qcbor") { + return false + } + return Widgets_AllowHeader(fullpath) + }, + cflags: pkgConfigCflags("Qt5Widgets"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + { + path: "qt/cbor", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtCore", + }, + allowHeader: func(fullpath string) bool { + // Only include the same json, xml, cbor files excluded above + fname := filepath.Base(fullpath) + return strings.HasPrefix(fname, "qcbor") + }, + cflags: pkgConfigCflags("Qt5Core"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 PrintSupport + { + path: "qt/printsupport", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtPrintSupport", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5PrintSupport"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 SVG + { + path: "qt/svg", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtSvg", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5Svg"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 Network (1/3) + { + path: "qt/network", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtNetwork", + }, + allowHeader: ExceptHeaders("qdtls.h", "qsctpserver.h", "qsctpsocket.h"), + cflags: pkgConfigCflags("Qt5Network"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 Network (2/3) + { + path: "qt/network/sctp", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtNetwork", + }, + allowHeader: OnlyHeaders("qsctpserver.h", "qsctpsocket.h"), + cflags: pkgConfigCflags("Qt5Network"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 Network (3/3) - split out DTLS into subpackage because macOS Brew is + // compiled with it disabled + // There are still some extra functions to move out from qsslconfiguration.h + // @ref https://github.com/mappu/miqt/issues/151 + + { + path: "qt/network/dtls", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtNetwork", + }, + allowHeader: OnlyHeaders("qdtls.h"), + cflags: pkgConfigCflags("Qt5Network"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 Multimedia + { + path: "qt/multimedia", + dirs: []string{ + // Theoretically, QtMultimediaWidgets and QtMultimedia are different + // packages, but QtMultimedia qcamera.h has a dependency on qvideowidget. + // Bind them together since our base /qt/ package is Widgets anyway. + "/usr/include/x86_64-linux-gnu/qt5/QtMultimedia", + "/usr/include/x86_64-linux-gnu/qt5/QtMultimediaWidgets", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5MultimediaWidgets"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 Script + { + path: "qt/script", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtScript", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5Script"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 WebKit: depends on Qt5PrintSupport but only at runtime, not at + // codegen time + { + path: "qt/webkit", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtWebKit", + "/usr/include/x86_64-linux-gnu/qt5/QtWebKitWidgets", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5WebKitWidgets"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 WebChannel + { + path: "qt/webchannel", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtWebChannel", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5WebChannel"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 WebEngine + { + path: "qt/webengine", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtWebEngine", + "/usr/include/x86_64-linux-gnu/qt5/QtWebEngineCore", + "/usr/include/x86_64-linux-gnu/qt5/QtWebEngineWidgets", + }, + allowHeader: ExceptHeaders("qquickwebengineprofile.h", "qquickwebenginescript.h"), + cflags: pkgConfigCflags("Qt5WebEngineWidgets"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // Qt 5 PDF + // Depends on QtCore/Gui/Widgets + { + path: "qt/pdf", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/QtPdf", + "/usr/include/x86_64-linux-gnu/qt5/QtPdfWidgets", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5PdfWidgets"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // QScintilla 5 + // Depends on QtCore/Gui/Widgets, QPrintSupport + { + path: "qt-restricted-extras/qscintilla", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt5/Qsci", + }, + allowHeader: AllowAllHeaders, + cflags: pkgConfigCflags("Qt5PrintSupport"), + clangMatcher: ClangMatchSameHeaderDefinitionOnly, + }, + + // QScintillaEdit 5 + // Depends on QtCore/Gui/Widgets + { + path: "qt-extras/scintillaedit", + dirs: []string{ + filepath.Join(extraLibsDir, "scintilla/qt/ScintillaEdit/ScintillaEdit.h"), + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++1z " + pkgConfigCflags("ScintillaEdit"), + clangMatcher: (&clangMatchUnderPath{filepath.Join(extraLibsDir, "scintilla")}).Match, }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5MultimediaWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - generate( - "qt/script", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtScript", - }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5Script"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 5 QWebkit: depends on Qt5PrintSupport but only at runtime, not at - // codegen time - generate( - "qt/webkit", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtWebKit", - "/usr/include/x86_64-linux-gnu/qt5/QtWebKitWidgets", - }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5WebKitWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 5 QWebChannel - generate( - "qt/webchannel", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtWebChannel", - }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5WebChannel"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 5 QWebEngine - generate( - "qt/webengine", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtWebEngine", - "/usr/include/x86_64-linux-gnu/qt5/QtWebEngineCore", - "/usr/include/x86_64-linux-gnu/qt5/QtWebEngineWidgets", - }, - ExceptHeaders("qquickwebengineprofile.h", "qquickwebenginescript.h"), - clangBin, - pkgConfigCflags("Qt5WebEngineWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 5 PDF - // Depends on QtCore/Gui/Widgets - generate( - "qt/pdf", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/QtPdf", - "/usr/include/x86_64-linux-gnu/qt5/QtPdfWidgets", - }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5PdfWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Depends on QtCore/Gui/Widgets, QPrintSupport - generate( - "qt-restricted-extras/qscintilla", - []string{ - "/usr/include/x86_64-linux-gnu/qt5/Qsci", - }, - AllowAllHeaders, - clangBin, - pkgConfigCflags("Qt5PrintSupport"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Depends on QtCore/Gui/Widgets - generate( - "qt-extras/scintillaedit", - []string{ - filepath.Join(extraLibsDir, "scintilla/qt/ScintillaEdit/ScintillaEdit.h"), - }, - AllowAllHeaders, - clangBin, - "--std=c++1z "+pkgConfigCflags("ScintillaEdit"), - outDir, - (&clangMatchUnderPath{filepath.Join(extraLibsDir, "scintilla")}).Match, - ) + } + + qtVersion = "qt5" + // PASS 1: Gather all types across all modules + for _, mod := range modules5 { + gatherTypes( + mod.path, + mod.dirs, + mod.allowHeader, + clangBin, + mod.cflags, + ) + } + + // PASS 2: Generate bindings with complete type information + for _, mod := range modules5 { + generate( + mod.path, + mod.dirs, + mod.allowHeader, + outDir, + mod.clangMatcher, + ) + } // FLUSH all known typedefs / ... flushKnownTypes() InsertTypedefs(true) - // Qt 6 - generate( - "qt6", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtCore", - "/usr/include/x86_64-linux-gnu/qt6/QtGui", - "/usr/include/x86_64-linux-gnu/qt6/QtWidgets", + // Qt 6 modules + modules6 := []moduleConfig{ + { + path: "qt6", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtCore", + "/usr/include/x86_64-linux-gnu/qt6/QtGui", + "/usr/include/x86_64-linux-gnu/qt6/QtWidgets", + }, + allowHeader: func(fullpath string) bool { + // Block cbor and generate it separately + fname := filepath.Base(fullpath) + if strings.HasPrefix(fname, "qcbor") { + return false + } + return Widgets_AllowHeader(fullpath) + }, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6Widgets"), + }, + + { + path: "qt6/cbor", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtCore", + }, + allowHeader: func(fullpath string) bool { + // Only include the same json, xml, cbor files excluded above + fname := filepath.Base(fullpath) + return strings.HasPrefix(fname, "qcbor") + }, + cflags: "--std=c++20 " + pkgConfigCflags("Qt6Core"), + }, + + // Qt 6 Qml + { + path: "qt6/qml", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtQml", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6Qml"), + }, + + // Qt 6 PrintSupport + { + path: "qt6/printsupport", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtPrintSupport", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6PrintSupport"), + }, + + // Qt 6 SVG + { + path: "qt6/svg", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtSvg", + "/usr/include/x86_64-linux-gnu/qt6/QtSvgWidgets", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6SvgWidgets"), + }, + + // Qt 6 QtNetwork (1/3) + { + path: "qt6/network", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtNetwork", + }, + allowHeader: ExceptHeaders("qtnetwork-config.h", "qsctpserver.h", "qsctpsocket.h", "qdtls.h"), + cflags: "--std=c++17 " + pkgConfigCflags("Qt6Network"), + }, + + // Qt 6 Network (2/3) - split out SCTP into subpackage because Arch Linux is + // compiled with it disabled + // @ref https://github.com/mappu/miqt/issues/150 + // @ref https://github.com/mappu/miqt/issues/194 + { + path: "qt6/network/sctp", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtNetwork", + }, + allowHeader: OnlyHeaders("qsctpserver.h", "qsctpsocket.h"), + cflags: "--std=c++17 " + pkgConfigCflags("Qt6Network"), + }, + + // Qt 6 Network (3/3) - split out DTLS into subpackage because macOS Brew is + // compiled with it disabled + // There are still some extra functions to move out from qsslconfiguration.h + // @ref https://github.com/mappu/miqt/issues/151 + { + path: "qt6/network/dtls", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtNetwork", + }, + allowHeader: OnlyHeaders("qdtls.h"), + cflags: "--std=c++17 " + pkgConfigCflags("Qt6Network"), + }, + + // Qt 6 Multimedia + { + path: "qt6/multimedia", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtMultimedia", + "/usr/include/x86_64-linux-gnu/qt6/QtMultimediaWidgets", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6MultimediaWidgets"), + }, + + // Qt 6 Spatial Audio (on Debian this is a dependency of Qt6Multimedia) + { + path: "qt6/spatialaudio", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtSpatialAudio", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6SpatialAudio"), + }, + + // Qt 6 WebChannel (1/2) + // Exclude qqmlwebchannel because Arch Linux packages it differently + // @ref https://github.com/mappu/miqt/issues/150 + // @ref https://github.com/mappu/miqt/issues/194 + { + path: "qt6/webchannel", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtWebChannel", + }, + allowHeader: ExceptHeaders("qqmlwebchannel.h"), + cflags: "--std=c++17 " + pkgConfigCflags("Qt6WebChannel"), + }, + + // Qt 6 WebChannel (2/2) + // Just the Qt Quick part of qqmlwebchannel + { + path: "qt6/webchannel/qmlwebchannel", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtWebChannel", + }, + allowHeader: OnlyHeaders("qqmlwebchannel.h"), + cflags: "--std=c++17 " + pkgConfigCflags("Qt6WebChannel"), + }, + + // Qt 6 WebEngine + { + path: "qt6/webengine", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtWebEngineCore", + "/usr/include/x86_64-linux-gnu/qt6/QtWebEngineWidgets", + }, + allowHeader: func(fullpath string) bool { + baseName := filepath.Base(fullpath) + return baseName != "qtwebenginewidgets-config.h" + }, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6WebEngineWidgets"), + }, + + // Qt 6 PDF + { + path: "qt6/pdf", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtPdf", + "/usr/include/x86_64-linux-gnu/qt6/QtPdfWidgets", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6PdfWidgets"), + }, + + // Qt 6 Charts + // Depends on QtCore/Gui/Widgets + { + path: "qt-restricted-extras/charts6", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/QtCharts", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6Charts"), + }, + + // QScintilla 6 + // Depends on QtCore/Gui/Widgets, QPrintSupport + { + path: "qt-restricted-extras/qscintilla6", + dirs: []string{ + "/usr/include/x86_64-linux-gnu/qt6/Qsci", + }, + allowHeader: AllowAllHeaders, + cflags: "--std=c++17 " + pkgConfigCflags("Qt6PrintSupport"), }, - func(fullpath string) bool { - // Block cbor and generate it separately - fname := filepath.Base(fullpath) - if strings.HasPrefix(fname, "qcbor") { - return false - } - - return Widgets_AllowHeader(fullpath) - }, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6Widgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - generate( - "qt6/cbor", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtCore", - }, - func(fullpath string) bool { - // Only include the same json, xml, cbor files excluded above - fname := filepath.Base(fullpath) - return strings.HasPrefix(fname, "qcbor") - }, - clangBin, - "--std=c++20 "+pkgConfigCflags("Qt6Core"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 QtQml - generate( - "qt6/qml", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtQml", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6Qml"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 QtPrintSupport - generate( - "qt6/printsupport", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtPrintSupport", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6PrintSupport"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 SVG - generate( - "qt6/svg", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtSvg", - "/usr/include/x86_64-linux-gnu/qt6/QtSvgWidgets", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6SvgWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 QtNetwork (1/3) - generate( - "qt6/network", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtNetwork", - }, - ExceptHeaders("qtnetwork-config.h", "qsctpserver.h", "qsctpsocket.h", "qdtls.h"), - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6Network"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 Network (2/3) - split out SCTP into subpackage because Arch Linux is - // compiled with it disabled - // @ref https://github.com/mappu/miqt/issues/150 - // @ref https://github.com/mappu/miqt/issues/194 - - generate( - "qt6/network/sctp", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtNetwork", - }, - OnlyHeaders("qsctpserver.h", "qsctpsocket.h"), - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6Network"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 Network (3/3) - split out DTLS into subpackage because macOS Brew is - // compiled with it disabled - // There are still some extra functions to move out from qsslconfiguration.h - // @ref https://github.com/mappu/miqt/issues/151 - - generate( - "qt6/network/dtls", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtNetwork", - }, - OnlyHeaders("qdtls.h"), - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6Network"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 QtMultimedia - generate( - "qt6/multimedia", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtMultimedia", - "/usr/include/x86_64-linux-gnu/qt6/QtMultimediaWidgets", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6MultimediaWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 Spatial Audio (on Debian this is a dependency of Qt6Multimedia) - generate( - "qt6/spatialaudio", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtSpatialAudio", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6SpatialAudio"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 QWebChannel (1/2) - // Exclude qqmlwebchannel because Arch Linux packages it differently - // @ref https://github.com/mappu/miqt/issues/150 - // @ref https://github.com/mappu/miqt/issues/194 - generate( - "qt6/webchannel", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtWebChannel", - }, - ExceptHeaders("qqmlwebchannel.h"), - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6WebChannel"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 WebChannel (2/2) - // Just the Qt Quick part of qqmlwebchannel - generate( - "qt6/webchannel/qmlwebchannel", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtWebChannel", - }, - OnlyHeaders("qqmlwebchannel.h"), - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6WebChannel"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 QWebEngine - generate( - "qt6/webengine", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtWebEngineCore", - "/usr/include/x86_64-linux-gnu/qt6/QtWebEngineWidgets", - }, - func(fullpath string) bool { - baseName := filepath.Base(fullpath) - if baseName == "qtwebenginewidgets-config.h" { - return false - } - return true - }, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6WebEngineWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 PDF - generate( - "qt6/pdf", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtPdf", - "/usr/include/x86_64-linux-gnu/qt6/QtPdfWidgets", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6PdfWidgets"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 Charts - // Depends on QtCore/Gui/Widgets - generate( - "qt-restricted-extras/charts6", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/QtCharts", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6Charts"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) - - // Qt 6 QScintilla - // Depends on QtCore/Gui/Widgets, QPrintSupport - generate( - "qt-restricted-extras/qscintilla6", - []string{ - "/usr/include/x86_64-linux-gnu/qt6/Qsci", - }, - AllowAllHeaders, - clangBin, - "--std=c++17 "+pkgConfigCflags("Qt6PrintSupport"), - outDir, - ClangMatchSameHeaderDefinitionOnly, - ) + } + + qtVersion = "qt6" + // PASS 1: Gather all types across all modules + for _, mod := range modules6 { + gatherTypes( + mod.path, + mod.dirs, + mod.allowHeader, + clangBin, + mod.cflags, + ) + } + + // PASS 2: Generate bindings with complete type information + for _, mod := range modules6 { + generate( + mod.path, + mod.dirs, + mod.allowHeader, + outDir, + ClangMatchSameHeaderDefinitionOnly, + ) + } } diff --git a/cmd/genbindings/main.go b/cmd/genbindings/main.go index d37ab80fbb..86737e251f 100644 --- a/cmd/genbindings/main.go +++ b/cmd/genbindings/main.go @@ -10,6 +10,7 @@ import ( "os/exec" "path/filepath" "runtime" + "sort" "strings" "sync" ) @@ -93,7 +94,146 @@ func pkgConfigCflags(packageName string) string { return string(stdout) } -func generate(packageName string, srcDirs []string, allowHeaderFn func(string) bool, clangBin, cflagsCombined, outDir string, matcher ClangMatcher) { +// getReferencedClasses finds all referenced Qt types in this header +func getReferencedClasses(src *CppParsedHeader) []string { + foundTypes := map[string]struct{}{} + + var maybeAddType = func(p CppParameter) { + if p.QtClassType() { + foundTypes[p.ParameterType] = struct{}{} + } + } + + for _, c := range src.Classes { + foundTypes[c.ClassName] = struct{}{} + + for _, ctor := range c.Ctors { + for _, p := range ctor.Parameters { + maybeAddType(p) + } + } + for _, m := range c.Methods { + for _, p := range m.Parameters { + maybeAddType(p) + } + maybeAddType(m.ReturnType) + } + for _, cn := range c.DirectInherits { + maybeAddType(CppParameter{ + ParameterType: cn, + }) + } + } + + // Some types (e.g. QRgb) are found but are typedefs, not classes + for _, td := range src.Typedefs { + delete(foundTypes, td.Alias) + } + + // Convert to sorted list + foundTypesList := make([]string, 0, len(foundTypes)) + for ft := range foundTypes { + if !AllowClass(ft) { + continue + } + + foundTypesList = append(foundTypesList, ft) + } + sort.Strings(foundTypesList) + + return foundTypesList +} + +// gatherTypes does just the type registration part previously done by generate() +func gatherTypes(name string, dirs []string, allowHeader func(string) bool, clangBin, cflagsCombined string) { + // + // PASS 0 (Fill clang cache) + // + + var includeFiles []string + for _, srcDir := range dirs { + if strings.HasSuffix(srcDir, `.h`) { + includeFiles = append(includeFiles, srcDir) + } else { + includeFiles = append(includeFiles, findHeadersInDir(srcDir, allowHeader)...) + } + } + + cflags := strings.Fields(cflagsCombined) + + generateClangCaches(includeFiles, clangBin, cflags, ClangMatchSameHeaderDefinitionOnly) + + // Build complete type registry + for _, inputHeader := range includeFiles { + cacheFile := cacheFilePath(inputHeader) + astJson, err := os.ReadFile(cacheFile) + if err != nil { + panic("Expected cache to be created for " + inputHeader + ", but got error " + err.Error()) + } + + var astInner []interface{} = nil + err = json.Unmarshal(astJson, &astInner) + if err != nil { + panic(err) + } + + parsed, err := parseHeader(astInner, "") + if err != nil { + panic(err) + } + + // Register all types + addKnownTypes(name, parsed) + + parsed.DetectedFlags = parsed.RegisterFlags() + refClasses := getReferencedClasses(parsed) + + for _, class := range parsed.Classes { + class.IncludedClasses = append(class.IncludedClasses, refClasses...) + + if qtVersion != "qt5" { + for _, enum := range class.ChildEnums { + shortName := enum.CabiEnumName() + + // Initialize maps if needed + if _, ok := EnumScopeRegistry[shortName]; !ok { + EnumScopeRegistry[shortName] = make(map[string]map[string]EnumScopeInfo) + } + if _, ok := EnumScopeRegistry[shortName][class.ClassName]; !ok { + EnumScopeRegistry[shortName][class.ClassName] = make(map[string]EnumScopeInfo) + } + + // Store the enum info + EnumScopeRegistry[shortName][class.ClassName][""] = EnumScopeInfo{ + FullyQualifiedName: enum.EnumName, + ClassScope: class.ClassName, + Namespace: "", + } + + // Register corresponding flags type + flagsShortName := shortName + "s" + flagsFullName := enum.EnumName + "s" + + if _, ok := EnumScopeRegistry[flagsShortName]; !ok { + EnumScopeRegistry[flagsShortName] = make(map[string]map[string]EnumScopeInfo) + } + if _, ok := EnumScopeRegistry[flagsShortName][class.ClassName]; !ok { + EnumScopeRegistry[flagsShortName][class.ClassName] = make(map[string]EnumScopeInfo) + } + + EnumScopeRegistry[flagsShortName][class.ClassName][""] = EnumScopeInfo{ + FullyQualifiedName: flagsFullName, + ClassScope: class.ClassName, + Namespace: "", + } + } + } + } + } + // The cache should now be fully populated +} + +func generate(packageName string, srcDirs []string, allowHeaderFn func(string) bool, outDir string, matcher ClangMatcher) { var includeFiles []string for _, srcDir := range srcDirs { @@ -106,8 +246,6 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b log.Printf("Found %d header files to process.", len(includeFiles)) - cflags := strings.Fields(cflagsCombined) - outDir = filepath.Join(outDir, packageName) cleanGeneratedFilesInDir(outDir) @@ -117,14 +255,6 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b preserve: make(map[string]*CppEnum), } - // - // PASS 0 (Fill clang cache) - // - - generateClangCaches(includeFiles, clangBin, cflags, matcher) - - // The cache should now be fully populated. - // // PASS 1 (clang2il) // @@ -158,7 +288,11 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b parsed.Filename = inputHeader // Stash // AST transforms on our IL - astTransformChildClasses(parsed) // must be first + astTransformChildClasses(parsed) // must be first + if qtVersion != "qt5" { + astTransformEnumResolution(parsed) + astTransformStructResolution(parsed) + } astTransformApplyQuirks(packageName, parsed) // must be before optional/overload expansion astTransformOptional(parsed) astTransformOverloads(parsed) From fc9df207aad102d07e2e0769817d8806ba8b40df Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Thu, 5 Jun 2025 23:33:58 -0400 Subject: [PATCH 06/12] transformquirks.go: Fix formatting --- cmd/genbindings/transformquirks.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/cmd/genbindings/transformquirks.go b/cmd/genbindings/transformquirks.go index 80ce954b7f..df88caf240 100644 --- a/cmd/genbindings/transformquirks.go +++ b/cmd/genbindings/transformquirks.go @@ -7,13 +7,13 @@ func astTransformApplyQuirks(packageName string, parsed *CppParsedHeader) { // Constructors - for j, _ := range c.Ctors { + for j := range c.Ctors { ApplyQuirks(packageName, c.ClassName, &parsed.Classes[i].Ctors[j]) } // Methods - for j, _ := range c.Methods { + for j := range c.Methods { ApplyQuirks(packageName, c.ClassName, &parsed.Classes[i].Methods[j]) } From 79776e590b28592d49fdd85b1bed3bbb9e3c67e1 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Fri, 4 Jul 2025 23:30:26 -0400 Subject: [PATCH 07/12] transformstructs.go: Initial commit --- cmd/genbindings/transformstructs.go | 222 ++++++++++++++++++++++++++++ 1 file changed, 222 insertions(+) create mode 100644 cmd/genbindings/transformstructs.go diff --git a/cmd/genbindings/transformstructs.go b/cmd/genbindings/transformstructs.go new file mode 100644 index 0000000000..6eba773a36 --- /dev/null +++ b/cmd/genbindings/transformstructs.go @@ -0,0 +1,222 @@ +package main + +import "strings" + +// Helper function to resolve any struct type, including inner classes +func resolveStructType(typeName, className, namespace string) string { + // Check if it's already a fully qualified name + if strings.HasPrefix(typeName, "Qt::") { + return typeName + } + + localTypeName := className + if idx := strings.LastIndex(className, "::"); idx != -1 { + localTypeName = className[idx+2:] + } + + for _, container := range qtContainers { + if strings.HasPrefix(typeName, container) { + openPos := strings.Index(typeName, "<") + closePos := strings.LastIndex(typeName, ">") + if openPos != -1 && closePos != -1 { + innerType := typeName[openPos+1 : closePos] + + // Check if inner type matches local type name + if innerType == localTypeName { + return container + className + ">" + } + + // Try class scope first + fullClassName := innerType + namespaceName := innerType + if !strings.Contains(innerType, "::") { + fullClassName = className + "::" + innerType + namespaceName = namespace + "::" + innerType + } + if _, ok := KnownClassnames[fullClassName]; ok { + return container + fullClassName + ">" + } else if namespace != "" { + // Try namespace scope + if _, ok := KnownClassnames[namespaceName]; ok { + return container + namespaceName + ">" + } + } + + if _, ok := KnownTypedefs[fullClassName]; ok { + return container + fullClassName + ">" + } else if namespace != "" { + if _, ok := KnownTypedefs[namespaceName]; ok { + return container + namespaceName + ">" + } + } + } + } + } + + // Check if it's a known type + if strings.Contains(typeName, "::") { + if _, ok := KnownClassnames[typeName]; ok { + return typeName + } + if _, ok := KnownTypedefs[typeName]; ok { + return typeName + } + } + + // Try class scope + classScoped := className + "::" + typeName + if _, ok := KnownClassnames[classScoped]; ok { + return classScoped + } + + if _, ok := KnownTypedefs[classScoped]; ok { + return classScoped + } + + // Try namespace scope + if namespace != "" { + namespaceScoped := namespace + "::" + typeName + if _, ok := KnownClassnames[namespaceScoped]; ok { + return namespaceScoped + } + if _, ok := KnownTypedefs[namespaceScoped]; ok { + return namespaceScoped + } + } + + return typeName +} + +func (method *CppMethod) resolveMethodStructTypes(className, namespace string) { // []CppMethod { + // Get the local type name (without scope) for self-reference checks + localTypeName := className + if idx := strings.LastIndex(className, "::"); idx != -1 { + localTypeName = className[idx+2:] + } + + // Resolve return type + for _, container := range qtContainers { + if strings.HasPrefix(method.ReturnType.ParameterType, container) { + openPos := strings.Index(method.ReturnType.ParameterType, "<") + closePos := strings.LastIndex(method.ReturnType.ParameterType, ">") + if openPos != -1 && closePos != -1 { + innerType := method.ReturnType.ParameterType[openPos+1 : closePos] + + // Check if inner type matches local type name + if innerType == localTypeName { + method.ReturnType.ParameterType = container + className + ">" + if _, ok := KnownTypedefs[className+"::"+innerType]; ok { + if method.ReturnType.QtCppOriginalType != nil { + method.ReturnType.QtCppOriginalType.ParameterType = className + "::" + innerType + } + } + continue + } + + // Try resolving from KnownClassnames + if _, ok := KnownClassnames[innerType]; ok { + method.ReturnType.ParameterType = container + innerType + ">" + } + + if _, ok := KnownTypedefs[className+"::"+innerType]; ok { + if method.ReturnType.QtCppOriginalType != nil { + method.ReturnType.QtCppOriginalType.ParameterType = className + "::" + innerType + } + } + + // Try class scope first + fullClassName := className + "::" + innerType + namespaceName := namespace + "::" + innerType + if _, ok := KnownClassnames[fullClassName]; ok { + method.ReturnType.ParameterType = container + fullClassName + ">" + if method.ReturnType.QtCppOriginalType != nil { + method.ReturnType.QtCppOriginalType.ParameterType = container + fullClassName + ">" + } + } else if namespace != "" { + // Try namespace scope + if _, ok := KnownClassnames[namespaceName]; ok { + method.ReturnType.ParameterType = container + namespaceName + ">" + if method.ReturnType.QtCppOriginalType != nil { + method.ReturnType.QtCppOriginalType.ParameterType = container + namespaceName + ">" + } + } + } + + if _, ok := KnownTypedefs[fullClassName]; ok { + if method.ReturnType.QtCppOriginalType != nil { + method.ReturnType.QtCppOriginalType.ParameterType = fullClassName + } + } else if namespace != "" { + if _, ok := KnownTypedefs[namespaceName]; ok { + if method.ReturnType.QtCppOriginalType != nil { + method.ReturnType.QtCppOriginalType.ParameterType = namespaceName + } + } + } + } + } + } + + // Resolve parameters + for i, param := range method.Parameters { + // Check if parameter type matches local type name + if param.ParameterType == localTypeName { + method.Parameters[i].ParameterType = className + continue + } + + for _, container := range qtContainers { + if strings.HasPrefix(param.ParameterType, container) { + openPos := strings.Index(param.ParameterType, "<") + closePos := strings.LastIndex(param.ParameterType, ">") + if openPos != -1 && closePos != -1 { + innerType := param.ParameterType[openPos+1 : closePos] + + // Try class scope first + fullClassName := className + "::" + innerType + namespaceName := namespace + "::" + innerType + if _, ok := KnownClassnames[fullClassName]; ok { + method.Parameters[i].ParameterType = container + fullClassName + ">" + } else if namespace != "" { + // Try namespace scope + if _, ok := KnownClassnames[namespaceName]; ok { + method.Parameters[i].ParameterType = container + namespaceName + ">" + } + } + } + } + } + } + + // Also handle direct struct types + method.ReturnType.ParameterType = resolveStructType(method.ReturnType.ParameterType, className, namespace) + if method.ReturnType.QtCppOriginalType != nil { + method.ReturnType.QtCppOriginalType.ParameterType = resolveStructType(method.ReturnType.QtCppOriginalType.ParameterType, className, namespace) + } + + // Handle parameters + for i, param := range method.Parameters { + method.Parameters[i].ParameterType = resolveStructType(param.ParameterType, className, namespace) + if method.Parameters[i].QtCppOriginalType != nil { + method.Parameters[i].QtCppOriginalType.ParameterType = resolveStructType(param.QtCppOriginalType.ParameterType, className, namespace) + } + } +} + +// Resolve struct types in class ctors and methods +func astTransformStructResolution(parsed *CppParsedHeader) { + for _, class := range parsed.Classes { + var namespace string + if strings.Contains(class.ClassName, "::") { + parts := strings.Split(class.ClassName, "::") + namespace = parts[0] + } + + for i := range class.Ctors { + class.Ctors[i].resolveMethodStructTypes(class.ClassName, namespace) + } + for i := range class.Methods { + class.Methods[i].resolveMethodStructTypes(class.ClassName, namespace) + } + } +} From a73ad69e639e8798f8aee89aa0b3c5d678faaad3 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Fri, 4 Jul 2025 23:33:37 -0400 Subject: [PATCH 08/12] config-allowlist.go: Add initial support for Qt 6.8 base --- cmd/genbindings/config-allowlist.go | 89 +++++++++++++++++++++-------- 1 file changed, 66 insertions(+), 23 deletions(-) diff --git a/cmd/genbindings/config-allowlist.go b/cmd/genbindings/config-allowlist.go index 299f30cb82..6ca1a37ff5 100644 --- a/cmd/genbindings/config-allowlist.go +++ b/cmd/genbindings/config-allowlist.go @@ -82,22 +82,32 @@ func Widgets_AllowHeader(fullpath string) bool { case "qatomic_bootstrap.h", "qatomic_cxx11.h", "qatomic_msvc.h", - "qgenericatomic.h", // Clang error - "qt_windows.h", // Clang error - "qmaccocoaviewcontainer_mac.h", // Needs NSView* headers. TODO allow with darwin build tag - "qmacnativewidget_mac.h", // Needs NSView* headers. TODO allow with darwin build tag - "qstring.h", // QString does not exist in this binding - "qbytearray.h", // QByteArray does not exist in this binding - "qlist.h", // QList does not exist in this binding - "qvector.h", // QVector does not exist in this binding - "qhash.h", // QHash does not exist in this binding - "qmap.h", // QMap does not exist in this binding - "qtcoreexports.h", // Nothing bindable here and has Q_CORE_EXPORT definition issues - "q20algorithm.h", // Qt 6 unstable header - "q20functional.h", // Qt 6 unstable header - "q20iterator.h", // Qt 6 unstable header - "q23functional.h", // Qt 6 unstable header - "qguiapplication_platform.h", // Qt 6 - can be built for X11 but then platform-specific code fails to build on Windows + "qgenericatomic.h", // Clang error + "qt_windows.h", // Clang error + "qmaccocoaviewcontainer_mac.h", // Needs NSView* headers. TODO allow with darwin build tag + "qmacnativewidget_mac.h", // Needs NSView* headers. TODO allow with darwin build tag + "qstring.h", // QString does not exist in this binding + "qbytearray.h", // QByteArray does not exist in this binding + "qlist.h", // QList does not exist in this binding + "qvector.h", // QVector does not exist in this binding + "qspan.h", // QSpan does not exist in this binding + "qhash.h", // QHash does not exist in this binding + "qmap.h", // QMap does not exist in this binding + "qtcoreexports.h", // Nothing bindable here and has Q_CORE_EXPORT definition issues + "q20algorithm.h", // Qt 6 unstable header + "q20functional.h", // Qt 6 unstable header + "q20iterator.h", // Qt 6 unstable header + "q23functional.h", // Qt 6 unstable header + "qguiapplication_platform.h", // Qt 6 - can be built for X11 but then platform-specific code fails to build on Windows + "qcomparehelpers.h", // Qt 6 - not meant to be included directly + "bus_interface.h", // Qt 6 - includes QtGui/private + "cache_adaptor.h", // Qt 6 - includes QtGui/private + "deviceeventcontroller_adaptor.h", // Qt 6 - includes QtGui/private + "properties_interface.h", // Qt 6 - includes QtGui/private + "socket_interface.h", // Qt 6 - includes QtGui/private + "qatomic.h", // Qt 6 - broken inheritance QAtomicInt => QAtomicInteger + "qrhiwidget.h", // Qt 6 - broken QRhi* types, granular blocking might be fine + "qscreen_platform.h", // Qt 6 - returns Wayland-specific wl_output type external to this library, a manual typedef does not work "____last____": return false } @@ -159,6 +169,9 @@ func ImportHeaderForClass(className string) bool { "QText", // e.g. qtextcursor.h "QVLABaseBase", // e.g. Qt 6 qvarlengtharray.h "QAdoptSharedDataTag", // Qt 6 qshareddata.h + "QGenericRunnable", // Qt 6.8 qrunnable.h + "QCameraPermission", // Qt 6.8 qpermissions.h + "QMicrophonePermission", // Qt 6.8 qpermissions.h "____last____": return false } @@ -183,10 +196,10 @@ func AllowClass(className string) bool { switch className { case - "QTextStreamManipulator", // Only seems to contain garbage methods - "QException", // Extends std::exception, too hard - "QUnhandledException", // As above (child class) - // "QItemSelection", // Extends a QList<>, too hard + "QTextStreamManipulator", // Only seems to contain garbage methods + "QException", // Extends std::exception, too hard + "QUnhandledException", // As above (child class) + "QGenericRunnable", // Qt 6, Unavailable class header in Qt 6.8 "QXmlStreamAttributes", // Extends a QList<>, too hard "QPolygon", // Extends a QVector template class, too hard "QPolygonF", // Extends a QVector template class, too hard @@ -275,7 +288,7 @@ func AllowVirtualForClass(className string) bool { // Pure virtual method registerEventNotifier takes a QWinEventNotifier* on Windows // which is platform-specific - if className == "QAbstractEventDispatcher" { + if strings.HasPrefix(className, "QAbstractEventDispatcher") { return false } @@ -301,6 +314,11 @@ func AllowVirtualForClass(className string) bool { return false } + // Qt 6.8 QImageIOHandler factory + if className == "QImageIOPlugin" { + return false + } + return true } @@ -310,7 +328,18 @@ func AllowMethod(className string, mm CppMethod) error { if strings.HasSuffix(p.ParameterType, "Private") { return ErrTooComplex // Skip private type } + if p.ParameterType == "Duration" { + return ErrTooComplex // Skip std::chrono alias + } + + if p.ParameterType == "..." { + return ErrTooComplex // Skip variadic parameter + } } + if mm.ReturnType.ParameterType == "Duration" { + return ErrTooComplex // Skip std::chrono alias + } + if strings.HasSuffix(mm.ReturnType.ParameterType, "Private") { return ErrTooComplex // Skip private type } @@ -381,6 +410,17 @@ func AllowMethod(className string, mm CppMethod) error { return ErrTooComplex // Callbacks that the attached object types must provide to QML } + if className == "QTransform" && mm.MethodName == "asAffineMatrix" { + // Qt 6.8: Skip this method, the return type is not properly handled yet + return ErrTooComplex + } + + if className == "QWebEnginePage" && mm.MethodName == "setFeaturePermission" { + // Qt 6.8: Skip this method, a parameter type is not properly handled yet + // and the function does not appear in the Qt documentation + return ErrTooComplex + } + // Skip functions that return ints-by-reference since the ergonomics don't // go through the binding if mm.ReturnType.IntType() && mm.ReturnType.ByRef { @@ -518,10 +558,13 @@ func AllowType(p CppParameter, isReturnType bool) error { // NewQtPrivate__ResultIteratorBase2(_mapIterator QMap__const_iterator) return ErrTooComplex } + if p.ParameterType == "QVersionNumber::It" { + return ErrTooComplex // e.g. Qt 6.8 qversionnumber.h + } if strings.Contains(p.ParameterType, `::QPrivate`) { return ErrTooComplex // e.g. QAbstractItemModel::QPrivateSignal } - if strings.Contains(p.GetQtCppType().ParameterType, `::DataPtr`) { + if strings.Contains(p.GetQtCppType().ParameterType, `DataPtr`) { return ErrTooComplex // e.g. QImage::data_ptr() } if strings.Contains(p.ParameterType, `::DataPointer`) { @@ -533,7 +576,7 @@ func AllowType(p CppParameter, isReturnType bool) error { // Some QFoo constructors take a QFooPrivate // QIcon also returns a QIconPrivate - if p.ParameterType[0] == 'Q' && strings.HasSuffix(p.ParameterType, "Private") { + if len(p.ParameterType) > 0 && p.ParameterType[0] == 'Q' && strings.HasSuffix(p.ParameterType, "Private") { return ErrTooComplex } if strings.HasPrefix(p.ParameterType, "QtPrivate::") { From 31416cb07c605092795d48f089e2fbadbeef32b6 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Fri, 4 Jul 2025 23:36:28 -0400 Subject: [PATCH 09/12] emitcabi.go: Add initial support for QSpan --- cmd/genbindings/emitcabi.go | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-) diff --git a/cmd/genbindings/emitcabi.go b/cmd/genbindings/emitcabi.go index cccc03f3cd..b11dd71a06 100644 --- a/cmd/genbindings/emitcabi.go +++ b/cmd/genbindings/emitcabi.go @@ -284,8 +284,22 @@ func emitCABI2CppForwarding(p CppParameter, indent string) (preamble string, for } else if listType, _, ok := p.QListOf(); ok { - preamble += indent + p.GetQtCppType().ParameterType + " " + nameprefix + "_QList;\n" - preamble += indent + nameprefix + "_QList.reserve(" + p.cParameterName() + ".len);\n" + // QSpan technically doesn't own the data but we use QList because we already + // have the structure in place to support the conversion with a patch for + // consideration for const types in some cases + paramType := p.GetQtCppType().ParameterType + containerQtType := strings.Replace(paramType, "QSpan<", "QList<", 1) + if strings.HasPrefix(containerQtType, "QList") { + containerQtType = strings.Replace(containerQtType, "const ", "", 1) + listType.Const = false + } + containerType := strings.Split(paramType, "<")[0] + containerType = strings.ReplaceAll(containerType, "::", "__") + + preamble += indent + containerQtType + " " + nameprefix + "_" + containerType + ";\n" + preamble += indent + nameprefix + "_" + containerType + ".reserve(" + p.ParameterName + ".len);\n" preamble += indent + listType.RenderTypeCabi() + "* " + nameprefix + "_arr = static_cast<" + listType.RenderTypeCabi() + "*>(" + p.cParameterName() + ".data);\n" preamble += indent + "for(size_t i = 0; i < " + p.cParameterName() + ".len; ++i) {\n" @@ -293,15 +307,15 @@ func emitCABI2CppForwarding(p CppParameter, indent string) (preamble string, for listType.ParameterName = nameprefix + "_arr[i]" addPre, addFwd := emitCABI2CppForwarding(listType, indent+"\t") preamble += addPre - preamble += indent + "\t" + nameprefix + "_QList.push_back(" + addFwd + ");\n" + preamble += indent + "\t" + nameprefix + "_" + containerType + ".push_back(" + addFwd + ");\n" preamble += indent + "}\n" // Support passing QList<>* (very rare, but used in qnetwork) if p.Pointer { - return preamble, "&" + nameprefix + "_QList" + return preamble, "&" + nameprefix + "_" + containerType } else { - return preamble, nameprefix + "_QList" + return preamble, nameprefix + "_" + containerType } } else if kType, vType, mapContainerType, ok := p.QMapOf(); ok { @@ -476,13 +490,13 @@ func emitAssignCppToCabi(assignExpression string, p CppParameter, rvalue string) shouldReturn = p.RenderTypeQtCpp() + " " + namePrefix + "_ret = " afterCall += indent + "// Convert QList<> from C++ memory to manually-managed C memory\n" - afterCall += indent + "" + t.RenderTypeCabi() + "* " + namePrefix + "_arr = static_cast<" + t.RenderTypeCabi() + "*>(malloc(sizeof(" + t.RenderTypeCabi() + ") * " + namePrefix + "_ret.length()));\n" - afterCall += indent + "for (size_t i = 0, e = " + namePrefix + "_ret.length(); i < e; ++i) {\n" + afterCall += indent + "" + t.RenderTypeCabi() + "* " + namePrefix + "_arr = static_cast<" + t.RenderTypeCabi() + "*>(malloc(sizeof(" + t.RenderTypeCabi() + ") * " + namePrefix + "_ret.size()));\n" + afterCall += indent + "for (size_t i = 0, e = " + namePrefix + "_ret.size(); i < e; ++i) {\n" afterCall += emitAssignCppToCabi(indent+"\t"+namePrefix+"_arr[i] = ", t, namePrefix+"_ret[i]") afterCall += indent + "}\n" afterCall += indent + "struct miqt_array " + namePrefix + "_out;\n" - afterCall += indent + "" + namePrefix + "_out.len = " + namePrefix + "_ret.length();\n" + afterCall += indent + "" + namePrefix + "_out.len = " + namePrefix + "_ret.size();\n" afterCall += indent + "" + namePrefix + "_out.data = static_cast(" + namePrefix + "_arr);\n" afterCall += indent + assignExpression + "" + namePrefix + "_out;\n" @@ -759,7 +773,7 @@ func cabiClassName(className string) string { func cabiPreventStructDeclaration(className string) bool { switch className { - case "QList", "QString", "QSet", "QMap", "QHash", "QPair", "QVector", "QByteArray": + case "QList", "QString", "QSet", "QMap", "QHash", "QPair", "QVector", "QByteArray", "QSpan": return true // These types are reprojected default: return false From e7a0cbfe7607a81398aa073dfd78205395c06bd3 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Fri, 4 Jul 2025 23:39:20 -0400 Subject: [PATCH 10/12] transformtypedefs.go: Expand type resolution for typedefs --- cmd/genbindings/transformtypedefs.go | 139 ++++++++++++++++++++++++--- 1 file changed, 124 insertions(+), 15 deletions(-) diff --git a/cmd/genbindings/transformtypedefs.go b/cmd/genbindings/transformtypedefs.go index 03302295f9..161d3f4e5b 100644 --- a/cmd/genbindings/transformtypedefs.go +++ b/cmd/genbindings/transformtypedefs.go @@ -1,66 +1,175 @@ package main -func applyTypedefs(p CppParameter) CppParameter { +import "strings" + +func applyTypedefs(p CppParameter, className string) CppParameter { + + namespace := "Qt" + if qtVersion != "qt5" { + if strings.Contains(className, "::") { + namespace = strings.Split(className, "::")[0] + } + + if strings.HasPrefix(p.ParameterType, "QtAudio::") { + p.ParameterType = strings.Replace(p.ParameterType, "QtAudio::", "QAudio::", 1) + } + + if etd, ok := KnownEnums[className+"::"+p.ParameterType]; ok && qtVersion != "qt5" { + p.ParameterType = resolveEnumType(etd.Enum.EnumName, className, namespace) + } + + if !strings.Contains(p.ParameterType, "iterator") { + if ctd, ok := KnownClassnames[p.ParameterType]; ok { + p.ParameterType = resolveStructType(ctd.Class.ClassName, className, namespace) + } + } else if _, ok := KnownClassnames[p.ParameterType]; ok { + p.ParameterType = resolveStructType(p.ParameterType, className, namespace) + } + + if ft, ok := KnownEnums[p.ParameterType+"Flag"]; ok && !strings.Contains(p.ParameterType, "::") && qtVersion != "qt5" { + p.ParameterType = strings.TrimSuffix(ft.Enum.EnumName, "Flag") + } + } for { + if qtVersion != "qt5" { + if tdd, ok := KnownTypedefs[className+"::"+p.ParameterType]; ok { + if strings.Contains(p.ParameterType, "value_type") || tdd.Typedef.Alias != "" { + p.ApplyTypedef(tdd.Typedef.UnderlyingType) + p.ParameterType = tdd.Typedef.Alias + } else { + p.ApplyTypedef(tdd.Typedef.UnderlyingType) + } + } + } + td, ok := KnownTypedefs[p.ParameterType] if !ok { break } p.ApplyTypedef(td.Typedef.UnderlyingType) + + if qtVersion != "qt5" { + if p.QtCppOriginalType != nil && strings.Contains(p.QtCppOriginalType.ParameterType, "const_pointer") { + p.QtCppOriginalType.ParameterType = className + "::" + "const_pointer" + p.PointerCount = 1 + } + } + } + + if fd, ok := KnownTypedefs[className+"::"+p.ParameterType]; ok && qtVersion != "qt5" { + p.ParameterType = fd.Typedef.Alias } if t, containerType, ok := p.QListOf(); ok { - t2 := applyTypedefs(t) // recursive + t2 := applyTypedefs(t, className) // recursive // Wipe out so that RenderTypeQtCpp() does not see it t2.QtCppOriginalType = nil + if qtVersion != "qt5" { + tType := resolveStructType(t2.RenderTypeQtCpp(), className, "") + p.ParameterType = containerType + `<` + tType + `>` + } + if p.QtCppOriginalType == nil { tmp := p // copy p.QtCppOriginalType = &tmp + if qtVersion != "qt5" { + p.QtCppOriginalType.ParameterType = p.ParameterType + } + } else { + if _, ok := KnownTypedefs[p.QtCppOriginalType.ParameterType]; ok && qtVersion != "qt5" { + p.QtCppOriginalType.ParameterType = p.ParameterType + } + } + + if qtVersion == "qt5" { + p.ParameterType = containerType + `<` + t2.RenderTypeQtCpp() + `>` } - p.ParameterType = containerType + `<` + t2.RenderTypeQtCpp() + `>` } else if kType, vType, containerType, ok := p.QMapOf(); ok { - kType2 := applyTypedefs(kType) + kType2 := applyTypedefs(kType, className) kType2.QtCppOriginalType = nil - vType2 := applyTypedefs(vType) + vType2 := applyTypedefs(vType, className) vType2.QtCppOriginalType = nil + var k2, v2 string + if qtVersion != "qt5" { + k2 = resolveStructType(kType2.RenderTypeQtCpp(), className, namespace) + v2 = resolveStructType(vType2.RenderTypeQtCpp(), className, namespace) + + p.ParameterType = containerType + `<` + k2 + `, ` + v2 + `>` + + } else { + k2 = kType2.RenderTypeQtCpp() + v2 = vType2.RenderTypeQtCpp() + } + if p.QtCppOriginalType == nil { tmp := p // copy p.QtCppOriginalType = &tmp + if qtVersion != "qt5" { + p.QtCppOriginalType.ParameterType = p.ParameterType + } + } else { + if _, ok := KnownTypedefs[p.QtCppOriginalType.ParameterType]; ok && qtVersion != "qt5" { + p.QtCppOriginalType.ParameterType = p.ParameterType + } + } + + if qtVersion == "qt5" { + p.ParameterType = containerType + `<` + k2 + `, ` + v2 + `>` } - p.ParameterType = containerType + `<` + kType2.RenderTypeQtCpp() + `, ` + vType2.RenderTypeQtCpp() + `>` } else if kType, vType, ok := p.QPairOf(); ok { - kType2 := applyTypedefs(kType) + kType2 := applyTypedefs(kType, className) kType2.QtCppOriginalType = nil - vType2 := applyTypedefs(vType) + vType2 := applyTypedefs(vType, className) vType2.QtCppOriginalType = nil + var k2, v2 string + if qtVersion != "qt5" { + k2 = resolveStructType(kType2.RenderTypeQtCpp(), className, namespace) + v2 = resolveStructType(vType2.RenderTypeQtCpp(), className, namespace) + + p.ParameterType = `QPair<` + k2 + `, ` + v2 + `>` + + } else { + k2 = kType2.RenderTypeQtCpp() + v2 = vType2.RenderTypeQtCpp() + } + if p.QtCppOriginalType == nil { tmp := p // copy p.QtCppOriginalType = &tmp + if qtVersion != "qt5" { + p.QtCppOriginalType.ParameterType = p.ParameterType + } + } else { + if _, ok := KnownTypedefs[p.QtCppOriginalType.ParameterType]; ok && qtVersion != "qt5" { + p.QtCppOriginalType.ParameterType = p.ParameterType + } } - p.ParameterType = `QPair<` + kType2.RenderTypeQtCpp() + `, ` + vType2.RenderTypeQtCpp() + `>` + if qtVersion == "qt5" { + p.ParameterType = `QPair<` + k2 + `, ` + v2 + `>` + } } return p } -func applyTypedefs_Method(m *CppMethod) { +func applyTypedefs_Method(m *CppMethod, className string) { for k, p := range m.Parameters { - transformed := applyTypedefs(p) + transformed := applyTypedefs(p, className) m.Parameters[k] = transformed } - m.ReturnType = applyTypedefs(m.ReturnType) + m.ReturnType = applyTypedefs(m.ReturnType, className) } // astTransformTypedefs replaces the ParameterType with any known typedef value. @@ -70,13 +179,13 @@ func astTransformTypedefs(parsed *CppParsedHeader) { for j, m := range c.Methods { - applyTypedefs_Method(&m) + applyTypedefs_Method(&m, c.ClassName) c.Methods[j] = m } for j, m := range c.Ctors { - applyTypedefs_Method(&m) + applyTypedefs_Method(&m, c.ClassName) c.Ctors[j] = m } parsed.Classes[i] = c @@ -84,7 +193,7 @@ func astTransformTypedefs(parsed *CppParsedHeader) { // Enum underlying types for i, e := range parsed.Enums { - e.UnderlyingType = applyTypedefs(e.UnderlyingType) + e.UnderlyingType = applyTypedefs(e.UnderlyingType, "") parsed.Enums[i] = e } } From c605309b0e1914b4b81d839236804938d4227d87 Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Sat, 5 Jul 2025 02:02:40 -0400 Subject: [PATCH 11/12] emitgo.go: Add support for uint8_t --- cmd/genbindings/emitgo.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cmd/genbindings/emitgo.go b/cmd/genbindings/emitgo.go index ca8548e7de..c14154e9dc 100644 --- a/cmd/genbindings/emitgo.go +++ b/cmd/genbindings/emitgo.go @@ -74,7 +74,7 @@ func (p CppParameter) RenderTypeGo(gfs *goFileState) string { ret := "" switch p.ParameterType { - case "unsigned char", "uchar", "quint8": + case "unsigned char", "uchar", "quint8", "uint8_t": // Go byte is unsigned ret += "byte" case "char", "qint8", "signed char": From ddb051b5f4407efdb37017c965d00152106d43ac Mon Sep 17 00:00:00 2001 From: Rick Calixte <10281587+rcalixte@users.noreply.github.com> Date: Thu, 5 Jun 2025 23:26:43 -0400 Subject: [PATCH 12/12] qt: Rebuild (Update type resolution) --- .../charts6/gen_qabstractbarseries.cpp | 34 +- .../charts6/gen_qabstractseries.cpp | 8 +- .../charts6/gen_qbarcategoryaxis.cpp | 12 +- qt-restricted-extras/charts6/gen_qbarset.cpp | 14 +- .../charts6/gen_qboxplotseries.cpp | 34 +- qt-restricted-extras/charts6/gen_qboxset.cpp | 2 +- .../charts6/gen_qcandlestickseries.cpp | 36 +- .../charts6/gen_qcategoryaxis.cpp | 8 +- qt-restricted-extras/charts6/gen_qchart.cpp | 32 +- qt-restricted-extras/charts6/gen_qlegend.cpp | 16 +- .../charts6/gen_qpieseries.cpp | 34 +- .../charts6/gen_qpolarchart.cpp | 24 +- .../charts6/gen_qxyseries.cpp | 26 +- .../qscintilla/gen_qsciabstractapis.cpp | 60 +-- .../qscintilla/gen_qsciapis.cpp | 94 ++--- .../qscintilla/gen_qscicommandset.cpp | 6 +- .../qscintilla/gen_qscilexer.cpp | 20 +- .../qscintilla/gen_qscilexeravs.cpp | 14 +- .../qscintilla/gen_qscilexerbash.cpp | 14 +- .../qscintilla/gen_qscilexerbatch.cpp | 14 +- .../qscintilla/gen_qscilexercmake.cpp | 14 +- .../qscintilla/gen_qscilexercoffeescript.cpp | 20 +- .../qscintilla/gen_qscilexercpp.cpp | 20 +- .../qscintilla/gen_qscilexercsharp.cpp | 14 +- .../qscintilla/gen_qscilexercss.cpp | 14 +- .../qscintilla/gen_qscilexercustom.cpp | 14 +- .../qscintilla/gen_qscilexerd.cpp | 20 +- .../qscintilla/gen_qscilexerdiff.cpp | 14 +- .../qscintilla/gen_qscilexeredifact.cpp | 14 +- .../qscintilla/gen_qscilexerfortran.cpp | 14 +- .../qscintilla/gen_qscilexerfortran77.cpp | 14 +- .../qscintilla/gen_qscilexerhtml.cpp | 14 +- .../qscintilla/gen_qscilexeridl.cpp | 14 +- .../qscintilla/gen_qscilexerjava.cpp | 14 +- .../qscintilla/gen_qscilexerjavascript.cpp | 14 +- .../qscintilla/gen_qscilexerjson.cpp | 14 +- .../qscintilla/gen_qscilexerlua.cpp | 20 +- .../qscintilla/gen_qscilexermakefile.cpp | 14 +- .../qscintilla/gen_qscilexermarkdown.cpp | 14 +- .../qscintilla/gen_qscilexermatlab.cpp | 14 +- .../qscintilla/gen_qscilexeroctave.cpp | 14 +- .../qscintilla/gen_qscilexerpascal.cpp | 20 +- .../qscintilla/gen_qscilexerperl.cpp | 20 +- .../qscintilla/gen_qscilexerpo.cpp | 14 +- .../qscintilla/gen_qscilexerpostscript.cpp | 14 +- .../qscintilla/gen_qscilexerpov.cpp | 14 +- .../qscintilla/gen_qscilexerproperties.cpp | 14 +- .../qscintilla/gen_qscilexerpython.cpp | 20 +- .../qscintilla/gen_qscilexerruby.cpp | 14 +- .../qscintilla/gen_qscilexerspice.cpp | 14 +- .../qscintilla/gen_qscilexersql.cpp | 14 +- .../qscintilla/gen_qscilexertcl.cpp | 14 +- .../qscintilla/gen_qscilexertex.cpp | 14 +- .../qscintilla/gen_qscilexerverilog.cpp | 14 +- .../qscintilla/gen_qscilexervhdl.cpp | 14 +- .../qscintilla/gen_qscilexerxml.cpp | 14 +- .../qscintilla/gen_qscilexeryaml.cpp | 14 +- .../qscintilla/gen_qsciscintilla.cpp | 42 +- .../qscintilla6/gen_qsciabstractapis.cpp | 52 +-- .../qscintilla6/gen_qsciapis.cpp | 72 ++-- .../qscintilla6/gen_qscicommandset.cpp | 8 +- .../qscintilla6/gen_qscilexer.cpp | 20 +- .../qscintilla6/gen_qscilexeravs.cpp | 12 +- .../qscintilla6/gen_qscilexerbash.cpp | 12 +- .../qscintilla6/gen_qscilexerbatch.cpp | 12 +- .../qscintilla6/gen_qscilexercmake.cpp | 12 +- .../qscintilla6/gen_qscilexercoffeescript.cpp | 20 +- .../qscintilla6/gen_qscilexercpp.cpp | 20 +- .../qscintilla6/gen_qscilexercsharp.cpp | 12 +- .../qscintilla6/gen_qscilexercss.cpp | 12 +- .../qscintilla6/gen_qscilexercustom.cpp | 12 +- .../qscintilla6/gen_qscilexerd.cpp | 20 +- .../qscintilla6/gen_qscilexerdiff.cpp | 12 +- .../qscintilla6/gen_qscilexeredifact.cpp | 12 +- .../qscintilla6/gen_qscilexerfortran.cpp | 12 +- .../qscintilla6/gen_qscilexerfortran77.cpp | 12 +- .../qscintilla6/gen_qscilexerhtml.cpp | 12 +- .../qscintilla6/gen_qscilexeridl.cpp | 12 +- .../qscintilla6/gen_qscilexerjava.cpp | 12 +- .../qscintilla6/gen_qscilexerjavascript.cpp | 12 +- .../qscintilla6/gen_qscilexerjson.cpp | 12 +- .../qscintilla6/gen_qscilexerlua.cpp | 20 +- .../qscintilla6/gen_qscilexermakefile.cpp | 12 +- .../qscintilla6/gen_qscilexermarkdown.cpp | 12 +- .../qscintilla6/gen_qscilexermatlab.cpp | 12 +- .../qscintilla6/gen_qscilexeroctave.cpp | 12 +- .../qscintilla6/gen_qscilexerpascal.cpp | 20 +- .../qscintilla6/gen_qscilexerperl.cpp | 20 +- .../qscintilla6/gen_qscilexerpo.cpp | 12 +- .../qscintilla6/gen_qscilexerpostscript.cpp | 12 +- .../qscintilla6/gen_qscilexerpov.cpp | 12 +- .../qscintilla6/gen_qscilexerproperties.cpp | 12 +- .../qscintilla6/gen_qscilexerpython.cpp | 20 +- .../qscintilla6/gen_qscilexerruby.cpp | 12 +- .../qscintilla6/gen_qscilexerspice.cpp | 12 +- .../qscintilla6/gen_qscilexersql.cpp | 12 +- .../qscintilla6/gen_qscilexertcl.cpp | 12 +- .../qscintilla6/gen_qscilexertex.cpp | 12 +- .../qscintilla6/gen_qscilexerverilog.cpp | 12 +- .../qscintilla6/gen_qscilexervhdl.cpp | 12 +- .../qscintilla6/gen_qscilexerxml.cpp | 12 +- .../qscintilla6/gen_qscilexeryaml.cpp | 12 +- .../qscintilla6/gen_qsciscintilla.cpp | 30 +- qt/cbor/gen_qcborarray.cpp | 22 +- qt/cbor/gen_qcbormap.cpp | 6 +- qt/gen_qabstracteventdispatcher.cpp | 6 +- qt/gen_qabstractitemdelegate.cpp | 20 +- qt/gen_qabstractitemmodel.cpp | 268 ++++++------- qt/gen_qabstractitemview.cpp | 28 +- qt/gen_qabstractproxymodel.cpp | 84 ++-- qt/gen_qabstractscrollarea.cpp | 6 +- qt/gen_qabstracttransition.cpp | 12 +- qt/gen_qaccessible.cpp | 48 +-- qt/gen_qaccessiblewidget.cpp | 18 +- qt/gen_qaction.cpp | 18 +- qt/gen_qactiongroup.cpp | 6 +- qt/gen_qapplication.cpp | 12 +- qt/gen_qbrush.cpp | 14 +- qt/gen_qbuttongroup.cpp | 6 +- qt/gen_qcalendar.cpp | 6 +- qt/gen_qcolor.cpp | 6 +- qt/gen_qcolormap.cpp | 6 +- qt/gen_qcolumnview.cpp | 34 +- qt/gen_qcombobox.cpp | 16 +- qt/gen_qcommandlineoption.cpp | 52 +-- qt/gen_qcommandlineparser.cpp | 46 +-- qt/gen_qcompleter.cpp | 36 +- qt/gen_qconcatenatetablesproxymodel.cpp | 90 ++--- qt/gen_qcoreapplication.cpp | 20 +- qt/gen_qdialogbuttonbox.cpp | 6 +- qt/gen_qdir.cpp | 168 ++++---- qt/gen_qdiriterator.cpp | 24 +- qt/gen_qdirmodel.cpp | 114 +++--- qt/gen_qeasingcurve.cpp | 6 +- qt/gen_qevent.cpp | 26 +- qt/gen_qfactoryinterface.cpp | 6 +- qt/gen_qfiledialog.cpp | 162 ++++---- qt/gen_qfileselector.cpp | 20 +- qt/gen_qfilesystemmodel.cpp | 98 ++--- qt/gen_qfilesystemwatcher.cpp | 56 +-- qt/gen_qfont.cpp | 34 +- qt/gen_qfontdatabase.cpp | 60 +-- qt/gen_qgenericpluginfactory.cpp | 6 +- qt/gen_qgesture.cpp | 18 +- qt/gen_qglyphrun.cpp | 28 +- qt/gen_qgraphicsitem.cpp | 24 +- qt/gen_qgraphicsitemanimation.cpp | 30 +- qt/gen_qgraphicsscene.cpp | 126 +++--- qt/gen_qgraphicsview.cpp | 54 +-- qt/gen_qgraphicswidget.cpp | 6 +- qt/gen_qguiapplication.cpp | 18 +- qt/gen_qheaderview.cpp | 28 +- qt/gen_qicon.cpp | 46 +-- qt/gen_qiconengine.cpp | 12 +- qt/gen_qidentityproxymodel.cpp | 76 ++-- qt/gen_qimage.cpp | 36 +- qt/gen_qimageiohandler.cpp | 359 ------------------ qt/gen_qimageiohandler.go | 312 --------------- qt/gen_qimageiohandler.h | 32 -- qt/gen_qimagereader.cpp | 30 +- qt/gen_qimagewriter.cpp | 24 +- qt/gen_qinputdialog.cpp | 62 +-- qt/gen_qitemdelegate.cpp | 14 +- qt/gen_qitemselectionmodel.cpp | 42 +- qt/gen_qjsonarray.cpp | 22 +- qt/gen_qjsonobject.cpp | 6 +- qt/gen_qkeysequence.cpp | 18 +- qt/gen_qlibraryinfo.cpp | 6 +- qt/gen_qlistview.cpp | 42 +- qt/gen_qlistwidget.cpp | 82 ++-- qt/gen_qlocale.cpp | 32 +- qt/gen_qmainwindow.cpp | 6 +- qt/gen_qmdiarea.cpp | 12 +- qt/gen_qmessagebox.cpp | 6 +- qt/gen_qmetaobject.cpp | 12 +- qt/gen_qmimedata.cpp | 26 +- qt/gen_qmimedatabase.cpp | 12 +- qt/gen_qmimetype.cpp | 30 +- qt/gen_qmovie.cpp | 6 +- qt/gen_qobject.cpp | 12 +- qt/gen_qpainter.cpp | 48 +-- qt/gen_qpainterpath.cpp | 14 +- qt/gen_qpen.cpp | 14 +- qt/gen_qpicture.cpp | 36 +- qt/gen_qplaintextedit.cpp | 6 +- qt/gen_qpluginloader.cpp | 12 +- qt/gen_qprocess.cpp | 94 ++--- qt/gen_qrawfont.cpp | 40 +- qt/gen_qregexp.cpp | 12 +- qt/gen_qregion.cpp | 6 +- qt/gen_qregularexpression.cpp | 12 +- qt/gen_qresource.cpp | 6 +- qt/gen_qscreen.cpp | 6 +- qt/gen_qscroller.cpp | 6 +- qt/gen_qsessionmanager.cpp | 36 +- qt/gen_qsettings.cpp | 18 +- qt/gen_qsortfilterproxymodel.cpp | 90 ++--- qt/gen_qsplitter.cpp | 6 +- qt/gen_qstandarditemmodel.cpp | 142 +++---- qt/gen_qstandardpaths.cpp | 26 +- qt/gen_qstate.cpp | 6 +- qt/gen_qstatemachine.cpp | 12 +- qt/gen_qstorageinfo.cpp | 6 +- qt/gen_qstringlistmodel.cpp | 100 ++--- qt/gen_qstringview.cpp | 6 +- qt/gen_qstyleditemdelegate.cpp | 14 +- qt/gen_qstylefactory.cpp | 6 +- qt/gen_qtableview.cpp | 28 +- qt/gen_qtablewidget.cpp | 88 ++--- qt/gen_qtextbrowser.cpp | 14 +- qt/gen_qtextcodec.cpp | 18 +- qt/gen_qtextdocument.cpp | 6 +- qt/gen_qtextdocumentwriter.cpp | 6 +- qt/gen_qtextedit.cpp | 6 +- qt/gen_qtextformat.cpp | 56 +-- qt/gen_qtextlayout.cpp | 72 ++-- qt/gen_qtextlist.cpp | 6 +- qt/gen_qtextobject.cpp | 30 +- qt/gen_qtextoption.cpp | 12 +- qt/gen_qtimezone.cpp | 36 +- qt/gen_qtouchdevice.cpp | 6 +- qt/gen_qtransposeproxymodel.cpp | 70 ++-- qt/gen_qtreeview.cpp | 36 +- qt/gen_qtreewidget.cpp | 134 +++---- qt/gen_qundogroup.cpp | 6 +- qt/gen_qundoview.cpp | 28 +- qt/gen_qurl.cpp | 48 +-- qt/gen_qurlquery.cpp | 24 +- qt/gen_qvariant.cpp | 20 +- qt/gen_qvariantanimation.cpp | 14 +- qt/gen_qversionnumber.cpp | 14 +- qt/gen_qwidget.cpp | 6 +- qt/gen_qwidgetaction.cpp | 6 +- qt/gen_qwizard.cpp | 18 +- qt/gen_qxmlstream.cpp | 26 +- qt/multimedia/gen_qabstractvideosurface.cpp | 6 +- qt/multimedia/gen_qaudiodecoder.cpp | 8 +- qt/multimedia/gen_qaudiodeviceinfo.cpp | 42 +- .../gen_qaudioencodersettingscontrol.cpp | 12 +- .../gen_qaudioinputselectorcontrol.cpp | 6 +- .../gen_qaudiooutputselectorcontrol.cpp | 6 +- qt/multimedia/gen_qaudiorecorder.cpp | 6 +- qt/multimedia/gen_qaudiorolecontrol.cpp | 6 +- qt/multimedia/gen_qaudiosystem.cpp | 36 +- qt/multimedia/gen_qaudiosystemplugin.cpp | 12 +- qt/multimedia/gen_qcamera.cpp | 54 +-- .../gen_qcameracapturebufferformatcontrol.cpp | 6 +- qt/multimedia/gen_qcameraexposure.cpp | 36 +- qt/multimedia/gen_qcameraexposurecontrol.cpp | 6 +- qt/multimedia/gen_qcamerafocus.cpp | 6 +- qt/multimedia/gen_qcamerafocuscontrol.cpp | 6 +- qt/multimedia/gen_qcameraimagecapture.cpp | 30 +- qt/multimedia/gen_qcamerainfo.cpp | 12 +- .../gen_qcameraviewfindersettingscontrol.cpp | 6 +- qt/multimedia/gen_qcustomaudiorolecontrol.cpp | 6 +- qt/multimedia/gen_qimageencodercontrol.cpp | 12 +- qt/multimedia/gen_qmediacontainercontrol.cpp | 6 +- qt/multimedia/gen_qmediacontent.cpp | 14 +- qt/multimedia/gen_qmediaobject.cpp | 6 +- qt/multimedia/gen_qmediaplayer.cpp | 48 +-- qt/multimedia/gen_qmediarecorder.cpp | 78 ++-- .../gen_qmediaserviceproviderplugin.cpp | 34 +- qt/multimedia/gen_qmediatimerange.cpp | 6 +- qt/multimedia/gen_qmetadatareadercontrol.cpp | 6 +- qt/multimedia/gen_qmetadatawritercontrol.cpp | 6 +- qt/multimedia/gen_qsoundeffect.cpp | 6 +- .../gen_qvideoencodersettingscontrol.cpp | 18 +- qt/multimedia/gen_qvideosurfaceformat.cpp | 6 +- qt/network/dtls/gen_qdtls.cpp | 14 +- qt/network/gen_qabstractnetworkcache.cpp | 14 +- qt/network/gen_qdnslookup.cpp | 48 +-- qt/network/gen_qhostinfo.cpp | 6 +- qt/network/gen_qnetworkaccessmanager.cpp | 32 +- qt/network/gen_qnetworkconfigmanager.cpp | 12 +- qt/network/gen_qnetworkconfiguration.cpp | 6 +- qt/network/gen_qnetworkcookie.cpp | 6 +- qt/network/gen_qnetworkcookiejar.cpp | 24 +- qt/network/gen_qnetworkinterface.cpp | 18 +- qt/network/gen_qnetworkproxy.cpp | 30 +- qt/network/gen_qnetworkreply.cpp | 18 +- qt/network/gen_qnetworkrequest.cpp | 6 +- qt/network/gen_qsslcertificate.cpp | 102 ++--- qt/network/gen_qsslconfiguration.cpp | 62 +-- qt/network/gen_qsslsocket.cpp | 72 ++-- qt/pdf/gen_qpdfbookmarkmodel.cpp | 70 ++-- qt/pdf/gen_qpdfsearchmodel.cpp | 76 ++-- qt/pdf/gen_qpdfsearchresult.cpp | 6 +- qt/printsupport/gen_qprinter.cpp | 6 +- qt/printsupport/gen_qprinterinfo.cpp | 48 +-- qt/script/gen_qscriptcontext.cpp | 12 +- qt/script/gen_qscriptcontextinfo.cpp | 6 +- qt/script/gen_qscriptengine.cpp | 18 +- qt/script/gen_qscriptextensioninterface.cpp | 8 +- qt/script/gen_qscriptextensionplugin.cpp | 14 +- qt/script/gen_qscriptvalue.cpp | 16 +- .../gen_qwebenginecertificateerror.cpp | 6 +- ...n_qwebengineclientcertificateselection.cpp | 6 +- .../gen_qwebengineclientcertificatestore.cpp | 6 +- .../gen_qwebenginecontextmenudata.cpp | 6 +- qt/webengine/gen_qwebenginehistory.cpp | 18 +- qt/webengine/gen_qwebenginehttprequest.cpp | 6 +- qt/webengine/gen_qwebenginepage.cpp | 44 +-- qt/webengine/gen_qwebenginepage.go | 4 - qt/webengine/gen_qwebenginepage.h | 1 - qt/webengine/gen_qwebengineprofile.cpp | 14 +- .../gen_qwebenginescriptcollection.cpp | 12 +- qt/webkit/gen_qwebelement.cpp | 24 +- qt/webkit/gen_qwebframe.cpp | 6 +- qt/webkit/gen_qwebhistory.cpp | 18 +- qt/webkit/gen_qwebkitplatformplugin.cpp | 8 +- qt/webkit/gen_qwebpage.cpp | 32 +- qt/webkit/gen_qwebpluginfactory.cpp | 32 +- qt/webkit/gen_qwebsecurityorigin.cpp | 18 +- qt/webkit/gen_qwebsettings.cpp | 14 +- qt6/cbor/gen_qcborarray.cpp | 12 +- qt6/cbor/gen_qcbormap.cpp | 24 +- qt6/gen_qabstracteventdispatcher.cpp | 6 +- qt6/gen_qabstractitemdelegate.cpp | 12 +- qt6/gen_qabstractitemmodel.cpp | 198 +++++----- qt6/gen_qabstractitemview.cpp | 18 +- qt6/gen_qabstractproxymodel.cpp | 60 +-- qt6/gen_qabstractscrollarea.cpp | 8 +- qt6/gen_qaccessible.cpp | 60 +-- qt6/gen_qaccessiblewidget.cpp | 24 +- qt6/gen_qaction.cpp | 14 +- qt6/gen_qactiongroup.cpp | 8 +- qt6/gen_qapplication.cpp | 16 +- qt6/gen_qarraydata.cpp | 2 +- qt6/gen_qbrush.cpp | 10 +- qt6/gen_qbuttongroup.cpp | 8 +- qt6/gen_qcalendar.cpp | 8 +- qt6/gen_qcolor.cpp | 8 +- qt6/gen_qcolormap.cpp | 6 +- qt6/gen_qcolumnview.cpp | 24 +- qt6/gen_qcombobox.cpp | 4 +- qt6/gen_qcommandlineoption.cpp | 26 +- qt6/gen_qcommandlineparser.cpp | 44 +-- qt6/gen_qcompleter.cpp | 28 +- qt6/gen_qconcatenatetablesproxymodel.cpp | 68 ++-- qt6/gen_qcoreapplication.cpp | 18 +- qt6/gen_qdialogbuttonbox.cpp | 8 +- qt6/gen_qdir.cpp | 146 +++---- qt6/gen_qdiriterator.cpp | 6 +- qt6/gen_qeasingcurve.cpp | 6 +- qt6/gen_qevent.cpp | 18 +- qt6/gen_qfactoryinterface.cpp | 8 +- qt6/gen_qfiledialog.cpp | 150 ++++---- qt6/gen_qfileselector.cpp | 18 +- qt6/gen_qfilesystemmodel.cpp | 70 ++-- qt6/gen_qfilesystemwatcher.cpp | 44 +-- qt6/gen_qfont.cpp | 36 +- qt6/gen_qfontdatabase.cpp | 68 ++-- qt6/gen_qgenericpluginfactory.cpp | 8 +- qt6/gen_qgesture.cpp | 28 +- qt6/gen_qgesturerecognizer.cpp | 2 +- qt6/gen_qglyphrun.cpp | 16 +- qt6/gen_qgraphicsitem.cpp | 34 +- qt6/gen_qgraphicsitemanimation.cpp | 40 +- qt6/gen_qgraphicsscene.cpp | 168 ++++---- qt6/gen_qgraphicsview.cpp | 72 ++-- qt6/gen_qgraphicswidget.cpp | 12 +- qt6/gen_qguiapplication.cpp | 24 +- qt6/gen_qheaderview.cpp | 18 +- qt6/gen_qicon.cpp | 38 +- qt6/gen_qiconengine.cpp | 12 +- qt6/gen_qidentityproxymodel.cpp | 58 +-- qt6/gen_qimage.cpp | 22 +- qt6/gen_qimageiohandler.cpp | 359 ------------------ qt6/gen_qimageiohandler.go | 312 --------------- qt6/gen_qimageiohandler.h | 32 -- qt6/gen_qimagereader.cpp | 32 +- qt6/gen_qimagewriter.cpp | 24 +- qt6/gen_qinputdevice.cpp | 16 +- qt6/gen_qinputdialog.cpp | 22 +- qt6/gen_qitemdelegate.cpp | 6 +- qt6/gen_qitemselectionmodel.cpp | 56 +-- qt6/gen_qjsonarray.cpp | 12 +- qt6/gen_qjsonobject.cpp | 16 +- qt6/gen_qkeysequence.cpp | 18 +- qt6/gen_qlayoutitem.cpp | 2 +- qt6/gen_qlibraryinfo.cpp | 8 +- qt6/gen_qlistview.cpp | 30 +- qt6/gen_qlistwidget.cpp | 70 ++-- qt6/gen_qlocale.cpp | 28 +- qt6/gen_qmainwindow.cpp | 10 +- qt6/gen_qmdiarea.cpp | 16 +- qt6/gen_qmenu.cpp | 6 +- qt6/gen_qmessagebox.cpp | 8 +- qt6/gen_qmetaobject.cpp | 12 +- qt6/gen_qmimedata.cpp | 26 +- qt6/gen_qmimedatabase.cpp | 12 +- qt6/gen_qmimetype.cpp | 40 +- qt6/gen_qmovie.cpp | 6 +- qt6/gen_qobject.cpp | 14 +- qt6/gen_qpageranges.cpp | 6 +- qt6/gen_qpainterpath.cpp | 10 +- qt6/gen_qpen.cpp | 10 +- qt6/gen_qplaintextedit.cpp | 6 +- qt6/gen_qpluginloader.cpp | 14 +- qt6/gen_qprocess.cpp | 56 +-- qt6/gen_qrawfont.cpp | 30 +- qt6/gen_qregularexpression.cpp | 16 +- qt6/gen_qscreen.cpp | 8 +- qt6/gen_qscroller.cpp | 12 +- qt6/gen_qsessionmanager.cpp | 22 +- qt6/gen_qsettings.cpp | 24 +- qt6/gen_qshortcut.cpp | 6 +- qt6/gen_qsortfilterproxymodel.cpp | 68 ++-- qt6/gen_qsplitter.cpp | 6 +- qt6/gen_qstandarditemmodel.cpp | 140 +++---- qt6/gen_qstandardpaths.cpp | 26 +- qt6/gen_qstorageinfo.cpp | 6 +- qt6/gen_qstringlistmodel.cpp | 68 ++-- qt6/gen_qstringview.cpp | 8 +- qt6/gen_qstyleditemdelegate.cpp | 6 +- qt6/gen_qstylefactory.cpp | 8 +- qt6/gen_qtableview.cpp | 18 +- qt6/gen_qtablewidget.cpp | 76 ++-- qt6/gen_qtextbrowser.cpp | 10 +- qt6/gen_qtextdocument.cpp | 6 +- qt6/gen_qtextdocumentwriter.cpp | 6 +- qt6/gen_qtextedit.cpp | 6 +- qt6/gen_qtextformat.cpp | 30 +- qt6/gen_qtextlayout.cpp | 42 +- qt6/gen_qtextlist.cpp | 6 +- qt6/gen_qtextobject.cpp | 32 +- qt6/gen_qtextoption.cpp | 16 +- qt6/gen_qtimezone.cpp | 38 +- qt6/gen_qtransposeproxymodel.cpp | 50 +-- qt6/gen_qtreeview.cpp | 18 +- qt6/gen_qtreewidget.cpp | 108 +++--- qt6/gen_qundogroup.cpp | 8 +- qt6/gen_qundoview.cpp | 18 +- qt6/gen_qurl.cpp | 34 +- qt6/gen_qurlquery.cpp | 28 +- qt6/gen_qvariant.cpp | 16 +- qt6/gen_qvariantanimation.cpp | 10 +- qt6/gen_qversionnumber.cpp | 6 +- qt6/gen_qwidget.cpp | 12 +- qt6/gen_qwidgetaction.cpp | 8 +- qt6/gen_qwizard.cpp | 12 +- qt6/gen_qxmlstream.cpp | 26 +- qt6/multimedia/gen_qaudiodevice.cpp | 6 +- qt6/multimedia/gen_qcameradevice.cpp | 12 +- qt6/multimedia/gen_qimagecapture.cpp | 6 +- qt6/multimedia/gen_qmediadevices.cpp | 18 +- qt6/multimedia/gen_qmediaformat.cpp | 18 +- qt6/multimedia/gen_qmediametadata.cpp | 6 +- qt6/multimedia/gen_qmediaplayer.cpp | 18 +- qt6/multimedia/gen_qmediatimerange.cpp | 6 +- qt6/multimedia/gen_qsoundeffect.cpp | 8 +- qt6/network/dtls/gen_qdtls.cpp | 6 +- qt6/network/gen_qabstractnetworkcache.cpp | 14 +- qt6/network/gen_qauthenticator.cpp | 2 +- qt6/network/gen_qdnslookup.cpp | 48 +-- qt6/network/gen_qhostinfo.cpp | 6 +- qt6/network/gen_qnetworkaccessmanager.cpp | 40 +- qt6/network/gen_qnetworkcookie.cpp | 6 +- qt6/network/gen_qnetworkcookiejar.cpp | 24 +- qt6/network/gen_qnetworkinformation.cpp | 8 +- qt6/network/gen_qnetworkinterface.cpp | 18 +- qt6/network/gen_qnetworkproxy.cpp | 30 +- qt6/network/gen_qnetworkreply.cpp | 20 +- qt6/network/gen_qnetworkrequest.cpp | 6 +- qt6/network/gen_qsslcertificate.cpp | 104 ++--- qt6/network/gen_qsslconfiguration.cpp | 54 +-- qt6/network/gen_qsslserver.cpp | 6 +- qt6/network/gen_qsslsocket.cpp | 72 ++-- qt6/pdf/gen_qpdfbookmarkmodel.cpp | 50 +-- qt6/pdf/gen_qpdflink.cpp | 6 +- qt6/pdf/gen_qpdfsearchmodel.cpp | 56 +-- qt6/printsupport/gen_qabstractprintdialog.cpp | 2 +- qt6/printsupport/gen_qprinter.cpp | 6 +- qt6/printsupport/gen_qprinterinfo.cpp | 38 +- qt6/qml/gen_qjsengine.cpp | 2 +- qt6/qml/gen_qjsmanagedvalue.cpp | 16 +- qt6/qml/gen_qjsvalue.cpp | 6 +- qt6/qml/gen_qqmlapplicationengine.cpp | 12 +- qt6/qml/gen_qqmlcomponent.cpp | 14 +- qt6/qml/gen_qqmldebug.cpp | 36 +- qt6/qml/gen_qqmlengine.cpp | 34 +- qt6/qml/gen_qqmlfileselector.cpp | 2 +- qt6/qml/gen_qqmlincubator.cpp | 8 +- qt6/qml/gen_qqmlpropertymap.cpp | 10 +- qt6/webchannel/gen_qwebchannel.cpp | 4 +- .../qmlwebchannel/gen_qqmlwebchannel.cpp | 2 +- .../gen_qwebenginecertificateerror.cpp | 6 +- ...n_qwebengineclientcertificateselection.cpp | 6 +- .../gen_qwebengineclientcertificatestore.cpp | 6 +- .../gen_qwebenginecontextmenurequest.cpp | 8 +- qt6/webengine/gen_qwebenginehistory.cpp | 18 +- qt6/webengine/gen_qwebenginehttprequest.cpp | 6 +- qt6/webengine/gen_qwebenginepage.cpp | 36 +- qt6/webengine/gen_qwebenginepage.go | 4 - qt6/webengine/gen_qwebenginepage.h | 1 - qt6/webengine/gen_qwebengineprofile.cpp | 10 +- .../gen_qwebenginescriptcollection.cpp | 12 +- 497 files changed, 6091 insertions(+), 7515 deletions(-) diff --git a/qt-restricted-extras/charts6/gen_qabstractbarseries.cpp b/qt-restricted-extras/charts6/gen_qabstractbarseries.cpp index b8afdc0144..13a92d64d0 100644 --- a/qt-restricted-extras/charts6/gen_qabstractbarseries.cpp +++ b/qt-restricted-extras/charts6/gen_qabstractbarseries.cpp @@ -77,7 +77,7 @@ bool QAbstractBarSeries_take(QAbstractBarSeries* self, QBarSet* set) { } bool QAbstractBarSeries_appendWithSets(QAbstractBarSeries* self, struct miqt_array /* of QBarSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QBarSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -95,14 +95,14 @@ int QAbstractBarSeries_count(const QAbstractBarSeries* self) { } struct miqt_array /* of QBarSet* */ QAbstractBarSeries_barSets(const QAbstractBarSeries* self) { - QList _ret = self->barSets(); + QList _ret = self->barSets(); // Convert QList<> from C++ memory to manually-managed C memory - QBarSet** _arr = static_cast(malloc(sizeof(QBarSet*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QBarSet** _arr = static_cast(malloc(sizeof(QBarSet*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -297,7 +297,7 @@ void QAbstractBarSeries_connect_labelsPrecisionChanged(QAbstractBarSeries* self, } void QAbstractBarSeries_barsetsAdded(QAbstractBarSeries* self, struct miqt_array /* of QBarSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QBarSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -307,15 +307,15 @@ void QAbstractBarSeries_barsetsAdded(QAbstractBarSeries* self, struct miqt_array } void QAbstractBarSeries_connect_barsetsAdded(QAbstractBarSeries* self, intptr_t slot) { - QAbstractBarSeries::connect(self, static_cast&)>(&QAbstractBarSeries::barsetsAdded), self, [=](const QList& sets) { - const QList& sets_ret = sets; + QAbstractBarSeries::connect(self, static_cast&)>(&QAbstractBarSeries::barsetsAdded), self, [=](const QList& sets) { + const QList& sets_ret = sets; // Convert QList<> from C++ memory to manually-managed C memory - QBarSet** sets_arr = static_cast(malloc(sizeof(QBarSet*) * sets_ret.length())); - for (size_t i = 0, e = sets_ret.length(); i < e; ++i) { + QBarSet** sets_arr = static_cast(malloc(sizeof(QBarSet*) * sets_ret.size())); + for (size_t i = 0, e = sets_ret.size(); i < e; ++i) { sets_arr[i] = sets_ret[i]; } struct miqt_array sets_out; - sets_out.len = sets_ret.length(); + sets_out.len = sets_ret.size(); sets_out.data = static_cast(sets_arr); struct miqt_array /* of QBarSet* */ sigval1 = sets_out; miqt_exec_callback_QAbstractBarSeries_barsetsAdded(slot, sigval1); @@ -323,7 +323,7 @@ void QAbstractBarSeries_connect_barsetsAdded(QAbstractBarSeries* self, intptr_t } void QAbstractBarSeries_barsetsRemoved(QAbstractBarSeries* self, struct miqt_array /* of QBarSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QBarSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -333,15 +333,15 @@ void QAbstractBarSeries_barsetsRemoved(QAbstractBarSeries* self, struct miqt_arr } void QAbstractBarSeries_connect_barsetsRemoved(QAbstractBarSeries* self, intptr_t slot) { - QAbstractBarSeries::connect(self, static_cast&)>(&QAbstractBarSeries::barsetsRemoved), self, [=](const QList& sets) { - const QList& sets_ret = sets; + QAbstractBarSeries::connect(self, static_cast&)>(&QAbstractBarSeries::barsetsRemoved), self, [=](const QList& sets) { + const QList& sets_ret = sets; // Convert QList<> from C++ memory to manually-managed C memory - QBarSet** sets_arr = static_cast(malloc(sizeof(QBarSet*) * sets_ret.length())); - for (size_t i = 0, e = sets_ret.length(); i < e; ++i) { + QBarSet** sets_arr = static_cast(malloc(sizeof(QBarSet*) * sets_ret.size())); + for (size_t i = 0, e = sets_ret.size(); i < e; ++i) { sets_arr[i] = sets_ret[i]; } struct miqt_array sets_out; - sets_out.len = sets_ret.length(); + sets_out.len = sets_ret.size(); sets_out.data = static_cast(sets_arr); struct miqt_array /* of QBarSet* */ sigval1 = sets_out; miqt_exec_callback_QAbstractBarSeries_barsetsRemoved(slot, sigval1); diff --git a/qt-restricted-extras/charts6/gen_qabstractseries.cpp b/qt-restricted-extras/charts6/gen_qabstractseries.cpp index 33d496f58d..eea43928a8 100644 --- a/qt-restricted-extras/charts6/gen_qabstractseries.cpp +++ b/qt-restricted-extras/charts6/gen_qabstractseries.cpp @@ -105,14 +105,14 @@ bool QAbstractSeries_detachAxis(QAbstractSeries* self, QAbstractAxis* axis) { } struct miqt_array /* of QAbstractAxis* */ QAbstractSeries_attachedAxes(QAbstractSeries* self) { - QList _ret = self->attachedAxes(); + QList _ret = self->attachedAxes(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/charts6/gen_qbarcategoryaxis.cpp b/qt-restricted-extras/charts6/gen_qbarcategoryaxis.cpp index 83542a78bc..170ff8fe6c 100644 --- a/qt-restricted-extras/charts6/gen_qbarcategoryaxis.cpp +++ b/qt-restricted-extras/charts6/gen_qbarcategoryaxis.cpp @@ -223,7 +223,7 @@ int QBarCategoryAxis_type(const QBarCategoryAxis* self) { } void QBarCategoryAxis_append(QBarCategoryAxis* self, struct miqt_array /* of struct miqt_string */ categories) { - QStringList categories_QList; + QList categories_QList; categories_QList.reserve(categories.len); struct miqt_string* categories_arr = static_cast(categories.data); for(size_t i = 0; i < categories.len; ++i) { @@ -259,7 +259,7 @@ void QBarCategoryAxis_clear(QBarCategoryAxis* self) { } void QBarCategoryAxis_setCategories(QBarCategoryAxis* self, struct miqt_array /* of struct miqt_string */ categories) { - QStringList categories_QList; + QList categories_QList; categories_QList.reserve(categories.len); struct miqt_string* categories_arr = static_cast(categories.data); for(size_t i = 0; i < categories.len; ++i) { @@ -270,10 +270,10 @@ void QBarCategoryAxis_setCategories(QBarCategoryAxis* self, struct miqt_array /* } struct miqt_array /* of struct miqt_string */ QBarCategoryAxis_categories(QBarCategoryAxis* self) { - QStringList _ret = self->categories(); + QList _ret = self->categories(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -284,7 +284,7 @@ struct miqt_array /* of struct miqt_string */ QBarCategoryAxis_categories(QBarC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/charts6/gen_qbarset.cpp b/qt-restricted-extras/charts6/gen_qbarset.cpp index 4d9a982f98..c2447be0a8 100644 --- a/qt-restricted-extras/charts6/gen_qbarset.cpp +++ b/qt-restricted-extras/charts6/gen_qbarset.cpp @@ -240,7 +240,7 @@ void QBarSet_append(QBarSet* self, const double value) { } void QBarSet_appendWithValues(QBarSet* self, struct miqt_array /* of double */ values) { - QList values_QList; + QList values_QList; values_QList.reserve(values.len); double* values_arr = static_cast(values.data); for(size_t i = 0; i < values.len; ++i) { @@ -407,12 +407,12 @@ void QBarSet_toggleSelection(QBarSet* self, struct miqt_array /* of int */ inde struct miqt_array /* of int */ QBarSet_selectedBars(const QBarSet* self) { QList _ret = self->selectedBars(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -618,12 +618,12 @@ void QBarSet_connect_selectedBarsChanged(QBarSet* self, intptr_t slot) { QBarSet::connect(self, static_cast&)>(&QBarSet::selectedBarsChanged), self, [=](const QList& indexes) { const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - int* indexes_arr = static_cast(malloc(sizeof(int) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + int* indexes_arr = static_cast(malloc(sizeof(int) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = indexes_ret[i]; } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of int */ sigval1 = indexes_out; miqt_exec_callback_QBarSet_selectedBarsChanged(slot, sigval1); diff --git a/qt-restricted-extras/charts6/gen_qboxplotseries.cpp b/qt-restricted-extras/charts6/gen_qboxplotseries.cpp index a3a4d45ee4..5f37c49427 100644 --- a/qt-restricted-extras/charts6/gen_qboxplotseries.cpp +++ b/qt-restricted-extras/charts6/gen_qboxplotseries.cpp @@ -240,7 +240,7 @@ bool QBoxPlotSeries_take(QBoxPlotSeries* self, QBoxSet* box) { } bool QBoxPlotSeries_appendWithBoxes(QBoxPlotSeries* self, struct miqt_array /* of QBoxSet* */ boxes) { - QList boxes_QList; + QList boxes_QList; boxes_QList.reserve(boxes.len); QBoxSet** boxes_arr = static_cast(boxes.data); for(size_t i = 0; i < boxes.len; ++i) { @@ -258,14 +258,14 @@ int QBoxPlotSeries_count(const QBoxPlotSeries* self) { } struct miqt_array /* of QBoxSet* */ QBoxPlotSeries_boxSets(const QBoxPlotSeries* self) { - QList _ret = self->boxSets(); + QList _ret = self->boxSets(); // Convert QList<> from C++ memory to manually-managed C memory - QBoxSet** _arr = static_cast(malloc(sizeof(QBoxSet*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QBoxSet** _arr = static_cast(malloc(sizeof(QBoxSet*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -419,7 +419,7 @@ void QBoxPlotSeries_connect_boxWidthChanged(QBoxPlotSeries* self, intptr_t slot) } void QBoxPlotSeries_boxsetsAdded(QBoxPlotSeries* self, struct miqt_array /* of QBoxSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QBoxSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -429,15 +429,15 @@ void QBoxPlotSeries_boxsetsAdded(QBoxPlotSeries* self, struct miqt_array /* of Q } void QBoxPlotSeries_connect_boxsetsAdded(QBoxPlotSeries* self, intptr_t slot) { - QBoxPlotSeries::connect(self, static_cast&)>(&QBoxPlotSeries::boxsetsAdded), self, [=](const QList& sets) { - const QList& sets_ret = sets; + QBoxPlotSeries::connect(self, static_cast&)>(&QBoxPlotSeries::boxsetsAdded), self, [=](const QList& sets) { + const QList& sets_ret = sets; // Convert QList<> from C++ memory to manually-managed C memory - QBoxSet** sets_arr = static_cast(malloc(sizeof(QBoxSet*) * sets_ret.length())); - for (size_t i = 0, e = sets_ret.length(); i < e; ++i) { + QBoxSet** sets_arr = static_cast(malloc(sizeof(QBoxSet*) * sets_ret.size())); + for (size_t i = 0, e = sets_ret.size(); i < e; ++i) { sets_arr[i] = sets_ret[i]; } struct miqt_array sets_out; - sets_out.len = sets_ret.length(); + sets_out.len = sets_ret.size(); sets_out.data = static_cast(sets_arr); struct miqt_array /* of QBoxSet* */ sigval1 = sets_out; miqt_exec_callback_QBoxPlotSeries_boxsetsAdded(slot, sigval1); @@ -445,7 +445,7 @@ void QBoxPlotSeries_connect_boxsetsAdded(QBoxPlotSeries* self, intptr_t slot) { } void QBoxPlotSeries_boxsetsRemoved(QBoxPlotSeries* self, struct miqt_array /* of QBoxSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QBoxSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -455,15 +455,15 @@ void QBoxPlotSeries_boxsetsRemoved(QBoxPlotSeries* self, struct miqt_array /* of } void QBoxPlotSeries_connect_boxsetsRemoved(QBoxPlotSeries* self, intptr_t slot) { - QBoxPlotSeries::connect(self, static_cast&)>(&QBoxPlotSeries::boxsetsRemoved), self, [=](const QList& sets) { - const QList& sets_ret = sets; + QBoxPlotSeries::connect(self, static_cast&)>(&QBoxPlotSeries::boxsetsRemoved), self, [=](const QList& sets) { + const QList& sets_ret = sets; // Convert QList<> from C++ memory to manually-managed C memory - QBoxSet** sets_arr = static_cast(malloc(sizeof(QBoxSet*) * sets_ret.length())); - for (size_t i = 0, e = sets_ret.length(); i < e; ++i) { + QBoxSet** sets_arr = static_cast(malloc(sizeof(QBoxSet*) * sets_ret.size())); + for (size_t i = 0, e = sets_ret.size(); i < e; ++i) { sets_arr[i] = sets_ret[i]; } struct miqt_array sets_out; - sets_out.len = sets_ret.length(); + sets_out.len = sets_ret.size(); sets_out.data = static_cast(sets_arr); struct miqt_array /* of QBoxSet* */ sigval1 = sets_out; miqt_exec_callback_QBoxPlotSeries_boxsetsRemoved(slot, sigval1); diff --git a/qt-restricted-extras/charts6/gen_qboxset.cpp b/qt-restricted-extras/charts6/gen_qboxset.cpp index f646feb80b..f63b8ba334 100644 --- a/qt-restricted-extras/charts6/gen_qboxset.cpp +++ b/qt-restricted-extras/charts6/gen_qboxset.cpp @@ -236,7 +236,7 @@ void QBoxSet_append(QBoxSet* self, const double value) { } void QBoxSet_appendWithValues(QBoxSet* self, struct miqt_array /* of double */ values) { - QList values_QList; + QList values_QList; values_QList.reserve(values.len); double* values_arr = static_cast(values.data); for(size_t i = 0; i < values.len; ++i) { diff --git a/qt-restricted-extras/charts6/gen_qcandlestickseries.cpp b/qt-restricted-extras/charts6/gen_qcandlestickseries.cpp index 9e304abc59..f44ba3c9f7 100644 --- a/qt-restricted-extras/charts6/gen_qcandlestickseries.cpp +++ b/qt-restricted-extras/charts6/gen_qcandlestickseries.cpp @@ -243,7 +243,7 @@ bool QCandlestickSeries_remove(QCandlestickSeries* self, QCandlestickSet* set) { } bool QCandlestickSeries_appendWithSets(QCandlestickSeries* self, struct miqt_array /* of QCandlestickSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QCandlestickSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -253,7 +253,7 @@ bool QCandlestickSeries_appendWithSets(QCandlestickSeries* self, struct miqt_arr } bool QCandlestickSeries_removeWithSets(QCandlestickSeries* self, struct miqt_array /* of QCandlestickSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QCandlestickSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -275,14 +275,14 @@ void QCandlestickSeries_clear(QCandlestickSeries* self) { } struct miqt_array /* of QCandlestickSet* */ QCandlestickSeries_sets(const QCandlestickSeries* self) { - QList _ret = self->sets(); + QList _ret = self->sets(); // Convert QList<> from C++ memory to manually-managed C memory - QCandlestickSet** _arr = static_cast(malloc(sizeof(QCandlestickSet*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCandlestickSet** _arr = static_cast(malloc(sizeof(QCandlestickSet*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -437,7 +437,7 @@ void QCandlestickSeries_connect_doubleClicked(QCandlestickSeries* self, intptr_t } void QCandlestickSeries_candlestickSetsAdded(QCandlestickSeries* self, struct miqt_array /* of QCandlestickSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QCandlestickSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -447,15 +447,15 @@ void QCandlestickSeries_candlestickSetsAdded(QCandlestickSeries* self, struct mi } void QCandlestickSeries_connect_candlestickSetsAdded(QCandlestickSeries* self, intptr_t slot) { - QCandlestickSeries::connect(self, static_cast&)>(&QCandlestickSeries::candlestickSetsAdded), self, [=](const QList& sets) { - const QList& sets_ret = sets; + QCandlestickSeries::connect(self, static_cast&)>(&QCandlestickSeries::candlestickSetsAdded), self, [=](const QList& sets) { + const QList& sets_ret = sets; // Convert QList<> from C++ memory to manually-managed C memory - QCandlestickSet** sets_arr = static_cast(malloc(sizeof(QCandlestickSet*) * sets_ret.length())); - for (size_t i = 0, e = sets_ret.length(); i < e; ++i) { + QCandlestickSet** sets_arr = static_cast(malloc(sizeof(QCandlestickSet*) * sets_ret.size())); + for (size_t i = 0, e = sets_ret.size(); i < e; ++i) { sets_arr[i] = sets_ret[i]; } struct miqt_array sets_out; - sets_out.len = sets_ret.length(); + sets_out.len = sets_ret.size(); sets_out.data = static_cast(sets_arr); struct miqt_array /* of QCandlestickSet* */ sigval1 = sets_out; miqt_exec_callback_QCandlestickSeries_candlestickSetsAdded(slot, sigval1); @@ -463,7 +463,7 @@ void QCandlestickSeries_connect_candlestickSetsAdded(QCandlestickSeries* self, i } void QCandlestickSeries_candlestickSetsRemoved(QCandlestickSeries* self, struct miqt_array /* of QCandlestickSet* */ sets) { - QList sets_QList; + QList sets_QList; sets_QList.reserve(sets.len); QCandlestickSet** sets_arr = static_cast(sets.data); for(size_t i = 0; i < sets.len; ++i) { @@ -473,15 +473,15 @@ void QCandlestickSeries_candlestickSetsRemoved(QCandlestickSeries* self, struct } void QCandlestickSeries_connect_candlestickSetsRemoved(QCandlestickSeries* self, intptr_t slot) { - QCandlestickSeries::connect(self, static_cast&)>(&QCandlestickSeries::candlestickSetsRemoved), self, [=](const QList& sets) { - const QList& sets_ret = sets; + QCandlestickSeries::connect(self, static_cast&)>(&QCandlestickSeries::candlestickSetsRemoved), self, [=](const QList& sets) { + const QList& sets_ret = sets; // Convert QList<> from C++ memory to manually-managed C memory - QCandlestickSet** sets_arr = static_cast(malloc(sizeof(QCandlestickSet*) * sets_ret.length())); - for (size_t i = 0, e = sets_ret.length(); i < e; ++i) { + QCandlestickSet** sets_arr = static_cast(malloc(sizeof(QCandlestickSet*) * sets_ret.size())); + for (size_t i = 0, e = sets_ret.size(); i < e; ++i) { sets_arr[i] = sets_ret[i]; } struct miqt_array sets_out; - sets_out.len = sets_ret.length(); + sets_out.len = sets_ret.size(); sets_out.data = static_cast(sets_arr); struct miqt_array /* of QCandlestickSet* */ sigval1 = sets_out; miqt_exec_callback_QCandlestickSeries_candlestickSetsRemoved(slot, sigval1); diff --git a/qt-restricted-extras/charts6/gen_qcategoryaxis.cpp b/qt-restricted-extras/charts6/gen_qcategoryaxis.cpp index a911953ec8..a6127a676e 100644 --- a/qt-restricted-extras/charts6/gen_qcategoryaxis.cpp +++ b/qt-restricted-extras/charts6/gen_qcategoryaxis.cpp @@ -252,10 +252,10 @@ double QCategoryAxis_endValue(const QCategoryAxis* self, struct miqt_string cate } struct miqt_array /* of struct miqt_string */ QCategoryAxis_categoriesLabels(QCategoryAxis* self) { - QStringList _ret = self->categoriesLabels(); + QList _ret = self->categoriesLabels(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -266,7 +266,7 @@ struct miqt_array /* of struct miqt_string */ QCategoryAxis_categoriesLabels(QC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/charts6/gen_qchart.cpp b/qt-restricted-extras/charts6/gen_qchart.cpp index f78d7219d7..481f38f8a5 100644 --- a/qt-restricted-extras/charts6/gen_qchart.cpp +++ b/qt-restricted-extras/charts6/gen_qchart.cpp @@ -1304,14 +1304,14 @@ void QChart_removeAllSeries(QChart* self) { } struct miqt_array /* of QAbstractSeries* */ QChart_series(const QChart* self) { - QList _ret = self->series(); + QList _ret = self->series(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractSeries** _arr = static_cast(malloc(sizeof(QAbstractSeries*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractSeries** _arr = static_cast(malloc(sizeof(QAbstractSeries*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1341,14 +1341,14 @@ void QChart_removeAxis(QChart* self, QAbstractAxis* axis) { } struct miqt_array /* of QAbstractAxis* */ QChart_axes(const QChart* self) { - QList _ret = self->axes(); + QList _ret = self->axes(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1617,27 +1617,27 @@ QAbstractAxis* QChart_axisYWithSeries(const QChart* self, QAbstractSeries* serie } struct miqt_array /* of QAbstractAxis* */ QChart_axesWithOrientation(const QChart* self, int orientation) { - QList _ret = self->axes(static_cast(orientation)); + QList _ret = self->axes(static_cast(orientation)); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QAbstractAxis* */ QChart_axes2(const QChart* self, int orientation, QAbstractSeries* series) { - QList _ret = self->axes(static_cast(orientation), series); + QList _ret = self->axes(static_cast(orientation), series); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/charts6/gen_qlegend.cpp b/qt-restricted-extras/charts6/gen_qlegend.cpp index d246a11ff9..ca0de48a00 100644 --- a/qt-restricted-extras/charts6/gen_qlegend.cpp +++ b/qt-restricted-extras/charts6/gen_qlegend.cpp @@ -155,14 +155,14 @@ bool QLegend_isBackgroundVisible(const QLegend* self) { } struct miqt_array /* of QLegendMarker* */ QLegend_markers(const QLegend* self) { - QList _ret = self->markers(); + QList _ret = self->markers(); // Convert QList<> from C++ memory to manually-managed C memory - QLegendMarker** _arr = static_cast(malloc(sizeof(QLegendMarker*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QLegendMarker** _arr = static_cast(malloc(sizeof(QLegendMarker*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -338,14 +338,14 @@ void QLegend_setBackgroundVisibleWithVisible(QLegend* self, bool visible) { } struct miqt_array /* of QLegendMarker* */ QLegend_markersWithSeries(const QLegend* self, QAbstractSeries* series) { - QList _ret = self->markers(series); + QList _ret = self->markers(series); // Convert QList<> from C++ memory to manually-managed C memory - QLegendMarker** _arr = static_cast(malloc(sizeof(QLegendMarker*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QLegendMarker** _arr = static_cast(malloc(sizeof(QLegendMarker*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/charts6/gen_qpieseries.cpp b/qt-restricted-extras/charts6/gen_qpieseries.cpp index 4076d2fa16..e312a7dcf7 100644 --- a/qt-restricted-extras/charts6/gen_qpieseries.cpp +++ b/qt-restricted-extras/charts6/gen_qpieseries.cpp @@ -232,7 +232,7 @@ bool QPieSeries_append(QPieSeries* self, QPieSlice* slice) { } bool QPieSeries_appendWithSlices(QPieSeries* self, struct miqt_array /* of QPieSlice* */ slices) { - QList slices_QList; + QList slices_QList; slices_QList.reserve(slices.len); QPieSlice** slices_arr = static_cast(slices.data); for(size_t i = 0; i < slices.len; ++i) { @@ -269,14 +269,14 @@ void QPieSeries_clear(QPieSeries* self) { } struct miqt_array /* of QPieSlice* */ QPieSeries_slices(const QPieSeries* self) { - QList _ret = self->slices(); + QList _ret = self->slices(); // Convert QList<> from C++ memory to manually-managed C memory - QPieSlice** _arr = static_cast(malloc(sizeof(QPieSlice*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPieSlice** _arr = static_cast(malloc(sizeof(QPieSlice*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -357,7 +357,7 @@ void QPieSeries_setLabelsPosition(QPieSeries* self, int position) { } void QPieSeries_added(QPieSeries* self, struct miqt_array /* of QPieSlice* */ slices) { - QList slices_QList; + QList slices_QList; slices_QList.reserve(slices.len); QPieSlice** slices_arr = static_cast(slices.data); for(size_t i = 0; i < slices.len; ++i) { @@ -367,15 +367,15 @@ void QPieSeries_added(QPieSeries* self, struct miqt_array /* of QPieSlice* */ s } void QPieSeries_connect_added(QPieSeries* self, intptr_t slot) { - QPieSeries::connect(self, static_cast&)>(&QPieSeries::added), self, [=](const QList& slices) { - const QList& slices_ret = slices; + QPieSeries::connect(self, static_cast&)>(&QPieSeries::added), self, [=](const QList& slices) { + const QList& slices_ret = slices; // Convert QList<> from C++ memory to manually-managed C memory - QPieSlice** slices_arr = static_cast(malloc(sizeof(QPieSlice*) * slices_ret.length())); - for (size_t i = 0, e = slices_ret.length(); i < e; ++i) { + QPieSlice** slices_arr = static_cast(malloc(sizeof(QPieSlice*) * slices_ret.size())); + for (size_t i = 0, e = slices_ret.size(); i < e; ++i) { slices_arr[i] = slices_ret[i]; } struct miqt_array slices_out; - slices_out.len = slices_ret.length(); + slices_out.len = slices_ret.size(); slices_out.data = static_cast(slices_arr); struct miqt_array /* of QPieSlice* */ sigval1 = slices_out; miqt_exec_callback_QPieSeries_added(slot, sigval1); @@ -383,7 +383,7 @@ void QPieSeries_connect_added(QPieSeries* self, intptr_t slot) { } void QPieSeries_removed(QPieSeries* self, struct miqt_array /* of QPieSlice* */ slices) { - QList slices_QList; + QList slices_QList; slices_QList.reserve(slices.len); QPieSlice** slices_arr = static_cast(slices.data); for(size_t i = 0; i < slices.len; ++i) { @@ -393,15 +393,15 @@ void QPieSeries_removed(QPieSeries* self, struct miqt_array /* of QPieSlice* */ } void QPieSeries_connect_removed(QPieSeries* self, intptr_t slot) { - QPieSeries::connect(self, static_cast&)>(&QPieSeries::removed), self, [=](const QList& slices) { - const QList& slices_ret = slices; + QPieSeries::connect(self, static_cast&)>(&QPieSeries::removed), self, [=](const QList& slices) { + const QList& slices_ret = slices; // Convert QList<> from C++ memory to manually-managed C memory - QPieSlice** slices_arr = static_cast(malloc(sizeof(QPieSlice*) * slices_ret.length())); - for (size_t i = 0, e = slices_ret.length(); i < e; ++i) { + QPieSlice** slices_arr = static_cast(malloc(sizeof(QPieSlice*) * slices_ret.size())); + for (size_t i = 0, e = slices_ret.size(); i < e; ++i) { slices_arr[i] = slices_ret[i]; } struct miqt_array slices_out; - slices_out.len = slices_ret.length(); + slices_out.len = slices_ret.size(); slices_out.data = static_cast(slices_arr); struct miqt_array /* of QPieSlice* */ sigval1 = slices_out; miqt_exec_callback_QPieSeries_removed(slot, sigval1); diff --git a/qt-restricted-extras/charts6/gen_qpolarchart.cpp b/qt-restricted-extras/charts6/gen_qpolarchart.cpp index 8bfd78c794..999f00bc4a 100644 --- a/qt-restricted-extras/charts6/gen_qpolarchart.cpp +++ b/qt-restricted-extras/charts6/gen_qpolarchart.cpp @@ -1289,14 +1289,14 @@ void QPolarChart_addAxis(QPolarChart* self, QAbstractAxis* axis, int polarOrient } struct miqt_array /* of QAbstractAxis* */ QPolarChart_axes(const QPolarChart* self) { - QList _ret = self->axes(); + QList _ret = self->axes(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1329,27 +1329,27 @@ struct miqt_string QPolarChart_tr3(const char* s, const char* c, int n) { } struct miqt_array /* of QAbstractAxis* */ QPolarChart_axesWithPolarOrientation(const QPolarChart* self, int polarOrientation) { - QList _ret = self->axes(static_cast(polarOrientation)); + QList _ret = self->axes(static_cast(polarOrientation)); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QAbstractAxis* */ QPolarChart_axes2(const QPolarChart* self, int polarOrientation, QAbstractSeries* series) { - QList _ret = self->axes(static_cast(polarOrientation), series); + QList _ret = self->axes(static_cast(polarOrientation), series); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAxis** _arr = static_cast(malloc(sizeof(QAbstractAxis*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/charts6/gen_qxyseries.cpp b/qt-restricted-extras/charts6/gen_qxyseries.cpp index bf3116199a..6716a553f4 100644 --- a/qt-restricted-extras/charts6/gen_qxyseries.cpp +++ b/qt-restricted-extras/charts6/gen_qxyseries.cpp @@ -142,12 +142,12 @@ int QXYSeries_count(const QXYSeries* self) { struct miqt_array /* of QPointF* */ QXYSeries_points(const QXYSeries* self) { QList _ret = self->points(); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -155,12 +155,12 @@ struct miqt_array /* of QPointF* */ QXYSeries_points(const QXYSeries* self) { struct miqt_array /* of QPointF* */ QXYSeries_pointsVector(const QXYSeries* self) { QList _ret = self->pointsVector(); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -344,12 +344,12 @@ void QXYSeries_toggleSelection(QXYSeries* self, struct miqt_array /* of int */ struct miqt_array /* of int */ QXYSeries_selectedPoints(const QXYSeries* self) { QList _ret = self->selectedPoints(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -392,7 +392,7 @@ bool QXYSeries_bestFitLineVisible(const QXYSeries* self) { } struct miqt_map /* tuple of double and double */ QXYSeries_bestFitLineEquation(const QXYSeries* self, bool* ok) { - QPair _ret = self->bestFitLineEquation(*ok); + QPair _ret = self->bestFitLineEquation(*ok); // Convert QPair<> from C++ memory to manually-managed C memory double* _first_arr = static_cast(malloc(sizeof(double))); double* _second_arr = static_cast(malloc(sizeof(double))); @@ -523,7 +523,7 @@ struct miqt_map /* of int to struct miqt_map of int to QVariant* */ QXYSerie } void QXYSeries_sizeBy(QXYSeries* self, struct miqt_array /* of double */ sourceData, const double minSize, const double maxSize) { - QList sourceData_QList; + QList sourceData_QList; sourceData_QList.reserve(sourceData.len); double* sourceData_arr = static_cast(sourceData.data); for(size_t i = 0; i < sourceData.len; ++i) { @@ -533,7 +533,7 @@ void QXYSeries_sizeBy(QXYSeries* self, struct miqt_array /* of double */ source } void QXYSeries_colorBy(QXYSeries* self, struct miqt_array /* of double */ sourceData) { - QList sourceData_QList; + QList sourceData_QList; sourceData_QList.reserve(sourceData.len); double* sourceData_arr = static_cast(sourceData.data); for(size_t i = 0; i < sourceData.len; ++i) { @@ -945,7 +945,7 @@ void QXYSeries_setBestFitLineVisibleWithVisible(QXYSeries* self, bool visible) { } void QXYSeries_colorBy2(QXYSeries* self, struct miqt_array /* of double */ sourceData, QLinearGradient* gradient) { - QList sourceData_QList; + QList sourceData_QList; sourceData_QList.reserve(sourceData.len); double* sourceData_arr = static_cast(sourceData.data); for(size_t i = 0; i < sourceData.len; ++i) { diff --git a/qt-restricted-extras/qscintilla/gen_qsciabstractapis.cpp b/qt-restricted-extras/qscintilla/gen_qsciabstractapis.cpp index ba4a09702c..ce5d917887 100644 --- a/qt-restricted-extras/qscintilla/gen_qsciabstractapis.cpp +++ b/qt-restricted-extras/qscintilla/gen_qsciabstractapis.cpp @@ -47,8 +47,8 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { const QStringList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -59,13 +59,13 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; QStringList& list_ret = list; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.length())); - for (size_t i = 0, e = list_ret.length(); i < e; ++i) { + struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.size())); + for (size_t i = 0, e = list_ret.size(); i < e; ++i) { QString list_lv_ret = list_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray list_lv_b = list_lv_ret.toUtf8(); @@ -76,7 +76,7 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { list_arr[i] = list_lv_ms; } struct miqt_array list_out; - list_out.len = list_ret.length(); + list_out.len = list_ret.size(); list_out.data = static_cast(list_arr); struct miqt_array /* of struct miqt_string */ sigval2 = list_out; miqt_exec_callback_QsciAbstractAPIs_updateAutoCompletionList(this, handle__updateAutoCompletionList, sigval1, sigval2); @@ -118,8 +118,8 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { const QStringList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -130,7 +130,7 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; int sigval2 = commas; @@ -138,23 +138,23 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { int sigval3 = static_cast(style_ret); QList& shifts_ret = shifts; // Convert QList<> from C++ memory to manually-managed C memory - int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.length())); - for (size_t i = 0, e = shifts_ret.length(); i < e; ++i) { + int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.size())); + for (size_t i = 0, e = shifts_ret.size(); i < e; ++i) { shifts_arr[i] = shifts_ret[i]; } struct miqt_array shifts_out; - shifts_out.len = shifts_ret.length(); + shifts_out.len = shifts_ret.size(); shifts_out.data = static_cast(shifts_arr); struct miqt_array /* of int */ sigval4 = shifts_out; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciAbstractAPIs_callTips(this, handle__callTips, sigval1, sigval2, sigval3, sigval4); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } // cgo.Handle value for overwritten implementation @@ -329,21 +329,21 @@ QsciLexer* QsciAbstractAPIs_lexer(const QsciAbstractAPIs* self) { } void QsciAbstractAPIs_updateAutoCompletionList(QsciAbstractAPIs* self, struct miqt_array /* of struct miqt_string */ context, struct miqt_array /* of struct miqt_string */ list) { - QStringList context_QList; - context_QList.reserve(context.len); + QStringList context_QStringList; + context_QStringList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); - context_QList.push_back(context_arr_i_QString); + context_QStringList.push_back(context_arr_i_QString); } - QStringList list_QList; - list_QList.reserve(list.len); + QStringList list_QStringList; + list_QStringList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { QString list_arr_i_QString = QString::fromUtf8(list_arr[i].data, list_arr[i].len); - list_QList.push_back(list_arr_i_QString); + list_QStringList.push_back(list_arr_i_QString); } - self->updateAutoCompletionList(context_QList, list_QList); + self->updateAutoCompletionList(context_QStringList, list_QStringList); } void QsciAbstractAPIs_autoCompletionSelected(QsciAbstractAPIs* self, struct miqt_string selection) { @@ -352,12 +352,12 @@ void QsciAbstractAPIs_autoCompletionSelected(QsciAbstractAPIs* self, struct miqt } struct miqt_array /* of struct miqt_string */ QsciAbstractAPIs_callTips(QsciAbstractAPIs* self, struct miqt_array /* of struct miqt_string */ context, int commas, int style, struct miqt_array /* of int */ shifts) { - QStringList context_QList; - context_QList.reserve(context.len); + QStringList context_QStringList; + context_QStringList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); - context_QList.push_back(context_arr_i_QString); + context_QStringList.push_back(context_arr_i_QString); } QList shifts_QList; shifts_QList.reserve(shifts.len); @@ -365,10 +365,10 @@ struct miqt_array /* of struct miqt_string */ QsciAbstractAPIs_callTips(QsciAbs for(size_t i = 0; i < shifts.len; ++i) { shifts_QList.push_back(static_cast(shifts_arr[i])); } - QStringList _ret = self->callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); + QStringList _ret = self->callTips(context_QStringList, static_cast(commas), static_cast(style), shifts_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -379,7 +379,7 @@ struct miqt_array /* of struct miqt_string */ QsciAbstractAPIs_callTips(QsciAbs _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qsciapis.cpp b/qt-restricted-extras/qscintilla/gen_qsciapis.cpp index 08bd5101e8..801d7df368 100644 --- a/qt-restricted-extras/qscintilla/gen_qsciapis.cpp +++ b/qt-restricted-extras/qscintilla/gen_qsciapis.cpp @@ -51,8 +51,8 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { const QStringList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -63,13 +63,13 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; QStringList& list_ret = list; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.length())); - for (size_t i = 0, e = list_ret.length(); i < e; ++i) { + struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.size())); + for (size_t i = 0, e = list_ret.size(); i < e; ++i) { QString list_lv_ret = list_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray list_lv_b = list_lv_ret.toUtf8(); @@ -80,7 +80,7 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { list_arr[i] = list_lv_ms; } struct miqt_array list_out; - list_out.len = list_ret.length(); + list_out.len = list_ret.size(); list_out.data = static_cast(list_arr); struct miqt_array /* of struct miqt_string */ sigval2 = list_out; miqt_exec_callback_QsciAPIs_updateAutoCompletionList(this, handle__updateAutoCompletionList, sigval1, sigval2); @@ -124,8 +124,8 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { const QStringList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -136,7 +136,7 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; int sigval2 = commas; @@ -144,23 +144,23 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { int sigval3 = static_cast(style_ret); QList& shifts_ret = shifts; // Convert QList<> from C++ memory to manually-managed C memory - int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.length())); - for (size_t i = 0, e = shifts_ret.length(); i < e; ++i) { + int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.size())); + for (size_t i = 0, e = shifts_ret.size(); i < e; ++i) { shifts_arr[i] = shifts_ret[i]; } struct miqt_array shifts_out; - shifts_out.len = shifts_ret.length(); + shifts_out.len = shifts_ret.size(); shifts_out.data = static_cast(shifts_arr); struct miqt_array /* of int */ sigval4 = shifts_out; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciAPIs_callTips(this, handle__callTips, sigval1, sigval2, sigval3, sigval4); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciAPIs_virtualbase_callTips(void* self, struct miqt_array /* of struct miqt_string */ context, int commas, int style, struct miqt_array /* of int */ shifts); @@ -383,21 +383,21 @@ bool QsciAPIs_savePrepared(const QsciAPIs* self) { } void QsciAPIs_updateAutoCompletionList(QsciAPIs* self, struct miqt_array /* of struct miqt_string */ context, struct miqt_array /* of struct miqt_string */ list) { - QStringList context_QList; - context_QList.reserve(context.len); + QStringList context_QStringList; + context_QStringList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); - context_QList.push_back(context_arr_i_QString); + context_QStringList.push_back(context_arr_i_QString); } - QStringList list_QList; - list_QList.reserve(list.len); + QStringList list_QStringList; + list_QStringList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { QString list_arr_i_QString = QString::fromUtf8(list_arr[i].data, list_arr[i].len); - list_QList.push_back(list_arr_i_QString); + list_QStringList.push_back(list_arr_i_QString); } - self->updateAutoCompletionList(context_QList, list_QList); + self->updateAutoCompletionList(context_QStringList, list_QStringList); } void QsciAPIs_autoCompletionSelected(QsciAPIs* self, struct miqt_string sel) { @@ -406,12 +406,12 @@ void QsciAPIs_autoCompletionSelected(QsciAPIs* self, struct miqt_string sel) { } struct miqt_array /* of struct miqt_string */ QsciAPIs_callTips(QsciAPIs* self, struct miqt_array /* of struct miqt_string */ context, int commas, int style, struct miqt_array /* of int */ shifts) { - QStringList context_QList; - context_QList.reserve(context.len); + QStringList context_QStringList; + context_QStringList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); - context_QList.push_back(context_arr_i_QString); + context_QStringList.push_back(context_arr_i_QString); } QList shifts_QList; shifts_QList.reserve(shifts.len); @@ -419,10 +419,10 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_callTips(QsciAPIs* self, for(size_t i = 0; i < shifts.len; ++i) { shifts_QList.push_back(static_cast(shifts_arr[i])); } - QStringList _ret = self->callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); + QStringList _ret = self->callTips(context_QStringList, static_cast(commas), static_cast(style), shifts_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -433,7 +433,7 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_callTips(QsciAPIs* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -445,8 +445,8 @@ bool QsciAPIs_event(QsciAPIs* self, QEvent* e) { struct miqt_array /* of struct miqt_string */ QsciAPIs_installedAPIFiles(const QsciAPIs* self) { QStringList _ret = self->installedAPIFiles(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -457,7 +457,7 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_installedAPIFiles(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -562,21 +562,21 @@ bool QsciAPIs_override_virtual_updateAutoCompletionList(void* self, intptr_t slo } void QsciAPIs_virtualbase_updateAutoCompletionList(void* self, struct miqt_array /* of struct miqt_string */ context, struct miqt_array /* of struct miqt_string */ list) { - QStringList context_QList; - context_QList.reserve(context.len); + QStringList context_QStringList; + context_QStringList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); - context_QList.push_back(context_arr_i_QString); + context_QStringList.push_back(context_arr_i_QString); } - QStringList list_QList; - list_QList.reserve(list.len); + QStringList list_QStringList; + list_QStringList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { QString list_arr_i_QString = QString::fromUtf8(list_arr[i].data, list_arr[i].len); - list_QList.push_back(list_arr_i_QString); + list_QStringList.push_back(list_arr_i_QString); } - static_cast(self)->QsciAPIs::updateAutoCompletionList(context_QList, list_QList); + static_cast(self)->QsciAPIs::updateAutoCompletionList(context_QStringList, list_QStringList); } bool QsciAPIs_override_virtual_autoCompletionSelected(void* self, intptr_t slot) { @@ -605,12 +605,12 @@ bool QsciAPIs_override_virtual_callTips(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QsciAPIs_virtualbase_callTips(void* self, struct miqt_array /* of struct miqt_string */ context, int commas, int style, struct miqt_array /* of int */ shifts) { - QStringList context_QList; - context_QList.reserve(context.len); + QStringList context_QStringList; + context_QStringList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); - context_QList.push_back(context_arr_i_QString); + context_QStringList.push_back(context_arr_i_QString); } QList shifts_QList; shifts_QList.reserve(shifts.len); @@ -618,10 +618,10 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_virtualbase_callTips(voi for(size_t i = 0; i < shifts.len; ++i) { shifts_QList.push_back(static_cast(shifts_arr[i])); } - QStringList _ret = static_cast(self)->QsciAPIs::callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); + QStringList _ret = static_cast(self)->QsciAPIs::callTips(context_QStringList, static_cast(commas), static_cast(style), shifts_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -632,7 +632,7 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_virtualbase_callTips(voi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscicommandset.cpp b/qt-restricted-extras/qscintilla/gen_qscicommandset.cpp index ff77b56bf6..9ae50d274f 100644 --- a/qt-restricted-extras/qscintilla/gen_qscicommandset.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscicommandset.cpp @@ -22,12 +22,12 @@ bool QsciCommandSet_writeSettings(QsciCommandSet* self, QSettings* qs) { struct miqt_array /* of QsciCommand* */ QsciCommandSet_commands(QsciCommandSet* self) { QList& _ret = self->commands(); // Convert QList<> from C++ memory to manually-managed C memory - QsciCommand** _arr = static_cast(malloc(sizeof(QsciCommand*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QsciCommand** _arr = static_cast(malloc(sizeof(QsciCommand*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexer.cpp b/qt-restricted-extras/qscintilla/gen_qscilexer.cpp index c5da074529..09e2a24133 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexer.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexer.cpp @@ -144,14 +144,14 @@ class MiqtVirtualQsciLexer final : public QsciLexer { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexer_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexer_virtualbase_autoCompletionWordSeparators(const void* self); @@ -842,8 +842,8 @@ const char* QsciLexer_autoCompletionFillups(const QsciLexer* self) { struct miqt_array /* of struct miqt_string */ QsciLexer_autoCompletionWordSeparators(const QsciLexer* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -854,7 +854,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexer_autoCompletionWordSepar _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1201,8 +1201,8 @@ bool QsciLexer_override_virtual_autoCompletionWordSeparators(void* self, intptr_ struct miqt_array /* of struct miqt_string */ QsciLexer_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexer::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1213,7 +1213,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexer_virtualbase_autoComplet _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexeravs.cpp b/qt-restricted-extras/qscintilla/gen_qscilexeravs.cpp index 0b887c6cc0..82c8b17dd9 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexeravs.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexeravs.cpp @@ -175,14 +175,14 @@ class MiqtVirtualQsciLexerAVS final : public QsciLexerAVS { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerAVS_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerAVS_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1048,8 +1048,8 @@ bool QsciLexerAVS_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerAVS_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerAVS::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1060,7 +1060,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerAVS_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerbash.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerbash.cpp index 9b325de2fa..805dfa585a 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerbash.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerbash.cpp @@ -175,14 +175,14 @@ class MiqtVirtualQsciLexerBash final : public QsciLexerBash { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerBash_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerBash_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1056,8 +1056,8 @@ bool QsciLexerBash_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerBash_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerBash::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1068,7 +1068,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerBash_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerbatch.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerbatch.cpp index 41bc267170..f384045c8e 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerbatch.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerbatch.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerBatch final : public QsciLexerBatch { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerBatch_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerBatch_virtualbase_autoCompletionWordSeparators(const void* self); @@ -970,8 +970,8 @@ bool QsciLexerBatch_override_virtual_autoCompletionWordSeparators(void* self, in struct miqt_array /* of struct miqt_string */ QsciLexerBatch_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerBatch::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -982,7 +982,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerBatch_virtualbase_autoCo _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexercmake.cpp b/qt-restricted-extras/qscintilla/gen_qscilexercmake.cpp index a682a78d70..361055e952 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexercmake.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexercmake.cpp @@ -157,14 +157,14 @@ class MiqtVirtualQsciLexerCMake final : public QsciLexerCMake { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCMake_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerCMake_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1004,8 +1004,8 @@ bool QsciLexerCMake_override_virtual_autoCompletionWordSeparators(void* self, in struct miqt_array /* of struct miqt_string */ QsciLexerCMake_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerCMake::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1016,7 +1016,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCMake_virtualbase_autoCo _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexercoffeescript.cpp b/qt-restricted-extras/qscintilla/gen_qscilexercoffeescript.cpp index 5fb0fd38b9..63a6ec18a2 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexercoffeescript.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexercoffeescript.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerCoffeeScript final : public QsciLexerCoffeeScript { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCoffeeScript_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_virtualbase_autoCompletionWordSeparators(const void* self); @@ -827,8 +827,8 @@ const char* QsciLexerCoffeeScript_lexer(const QsciLexerCoffeeScript* self) { struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_autoCompletionWordSeparators(const QsciLexerCoffeeScript* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -839,7 +839,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_autoComplet _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1052,8 +1052,8 @@ bool QsciLexerCoffeeScript_override_virtual_autoCompletionWordSeparators(void* s struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerCoffeeScript::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1064,7 +1064,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_virtualbase _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexercpp.cpp b/qt-restricted-extras/qscintilla/gen_qscilexercpp.cpp index 49a60089d4..1ea7da7cc3 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexercpp.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexercpp.cpp @@ -230,14 +230,14 @@ class MiqtVirtualQsciLexerCPP final : public QsciLexerCPP { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCPP_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerCPP_virtualbase_autoCompletionWordSeparators(const void* self); @@ -922,8 +922,8 @@ const char* QsciLexerCPP_lexer(const QsciLexerCPP* self) { struct miqt_array /* of struct miqt_string */ QsciLexerCPP_autoCompletionWordSeparators(const QsciLexerCPP* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -934,7 +934,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCPP_autoCompletionWordSe _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1273,8 +1273,8 @@ bool QsciLexerCPP_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerCPP_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerCPP::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1285,7 +1285,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCPP_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexercsharp.cpp b/qt-restricted-extras/qscintilla/gen_qscilexercsharp.cpp index 97daa7539a..c31e41a4ec 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexercsharp.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexercsharp.cpp @@ -229,14 +229,14 @@ class MiqtVirtualQsciLexerCSharp final : public QsciLexerCSharp { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCSharp_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerCSharp_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1120,8 +1120,8 @@ bool QsciLexerCSharp_override_virtual_autoCompletionWordSeparators(void* self, i struct miqt_array /* of struct miqt_string */ QsciLexerCSharp_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerCSharp::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1132,7 +1132,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCSharp_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexercss.cpp b/qt-restricted-extras/qscintilla/gen_qscilexercss.cpp index 74fc19abbd..e5718d57b7 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexercss.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexercss.cpp @@ -175,14 +175,14 @@ class MiqtVirtualQsciLexerCSS final : public QsciLexerCSS { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCSS_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerCSS_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1084,8 +1084,8 @@ bool QsciLexerCSS_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerCSS_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerCSS::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1096,7 +1096,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCSS_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexercustom.cpp b/qt-restricted-extras/qscintilla/gen_qscilexercustom.cpp index 9f10ac1396..0d3978a97f 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexercustom.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexercustom.cpp @@ -187,14 +187,14 @@ class MiqtVirtualQsciLexerCustom final : public QsciLexerCustom { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCustom_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerCustom_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1005,8 +1005,8 @@ bool QsciLexerCustom_override_virtual_autoCompletionWordSeparators(void* self, i struct miqt_array /* of struct miqt_string */ QsciLexerCustom_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerCustom::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1017,7 +1017,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCustom_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerd.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerd.cpp index 0bfdaf68d4..1b6f0c8078 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerd.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerd.cpp @@ -193,14 +193,14 @@ class MiqtVirtualQsciLexerD final : public QsciLexerD { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerD_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerD_virtualbase_autoCompletionWordSeparators(const void* self); @@ -881,8 +881,8 @@ const char* QsciLexerD_lexer(const QsciLexerD* self) { struct miqt_array /* of struct miqt_string */ QsciLexerD_autoCompletionWordSeparators(const QsciLexerD* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -893,7 +893,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerD_autoCompletionWordSepa _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1140,8 +1140,8 @@ bool QsciLexerD_override_virtual_autoCompletionWordSeparators(void* self, intptr struct miqt_array /* of struct miqt_string */ QsciLexerD_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerD::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1152,7 +1152,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerD_virtualbase_autoComple _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerdiff.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerdiff.cpp index 9f997d3b2f..0fbe79b55d 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerdiff.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerdiff.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerDiff final : public QsciLexerDiff { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerDiff_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerDiff_virtualbase_autoCompletionWordSeparators(const void* self); @@ -950,8 +950,8 @@ bool QsciLexerDiff_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerDiff_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerDiff::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -962,7 +962,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerDiff_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexeredifact.cpp b/qt-restricted-extras/qscintilla/gen_qscilexeredifact.cpp index f4133620a2..4cd626bde9 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexeredifact.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexeredifact.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerEDIFACT final : public QsciLexerEDIFACT { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerEDIFACT_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerEDIFACT_virtualbase_autoCompletionWordSeparators(const void* self); @@ -946,8 +946,8 @@ bool QsciLexerEDIFACT_override_virtual_autoCompletionWordSeparators(void* self, struct miqt_array /* of struct miqt_string */ QsciLexerEDIFACT_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerEDIFACT::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -958,7 +958,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerEDIFACT_virtualbase_auto _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerfortran.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerfortran.cpp index 676a06fa28..27cb3ec0d5 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerfortran.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerfortran.cpp @@ -157,14 +157,14 @@ class MiqtVirtualQsciLexerFortran final : public QsciLexerFortran { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerFortran_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerFortran_virtualbase_autoCompletionWordSeparators(const void* self); @@ -969,8 +969,8 @@ bool QsciLexerFortran_override_virtual_autoCompletionWordSeparators(void* self, struct miqt_array /* of struct miqt_string */ QsciLexerFortran_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerFortran::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -981,7 +981,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerFortran_virtualbase_auto _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerfortran77.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerfortran77.cpp index 8b8f757ba2..c2e1e1469c 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerfortran77.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerfortran77.cpp @@ -157,14 +157,14 @@ class MiqtVirtualQsciLexerFortran77 final : public QsciLexerFortran77 { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerFortran77_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerFortran77_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1012,8 +1012,8 @@ bool QsciLexerFortran77_override_virtual_autoCompletionWordSeparators(void* self struct miqt_array /* of struct miqt_string */ QsciLexerFortran77_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerFortran77::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1024,7 +1024,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerFortran77_virtualbase_au _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerhtml.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerhtml.cpp index d2f99a5eac..a983444ad0 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerhtml.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerhtml.cpp @@ -193,14 +193,14 @@ class MiqtVirtualQsciLexerHTML final : public QsciLexerHTML { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerHTML_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerHTML_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1128,8 +1128,8 @@ bool QsciLexerHTML_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerHTML_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerHTML::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1140,7 +1140,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerHTML_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexeridl.cpp b/qt-restricted-extras/qscintilla/gen_qscilexeridl.cpp index 9ea9c83f9c..bbb1ba9a43 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexeridl.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexeridl.cpp @@ -229,14 +229,14 @@ class MiqtVirtualQsciLexerIDL final : public QsciLexerIDL { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerIDL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerIDL_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1108,8 +1108,8 @@ bool QsciLexerIDL_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerIDL_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerIDL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1120,7 +1120,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerIDL_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerjava.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerjava.cpp index a3c0e6b013..adf7eda73b 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerjava.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerjava.cpp @@ -229,14 +229,14 @@ class MiqtVirtualQsciLexerJava final : public QsciLexerJava { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerJava_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerJava_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1093,8 +1093,8 @@ bool QsciLexerJava_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerJava_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerJava::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1105,7 +1105,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerJava_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerjavascript.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerjavascript.cpp index 928837e27c..5c7cf0001b 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerjavascript.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerjavascript.cpp @@ -229,14 +229,14 @@ class MiqtVirtualQsciLexerJavaScript final : public QsciLexerJavaScript { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerJavaScript_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerJavaScript_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1120,8 +1120,8 @@ bool QsciLexerJavaScript_override_virtual_autoCompletionWordSeparators(void* sel struct miqt_array /* of struct miqt_string */ QsciLexerJavaScript_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerJavaScript::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1132,7 +1132,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerJavaScript_virtualbase_a _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerjson.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerjson.cpp index d80e8c121c..fb975d1162 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerjson.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerjson.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerJSON final : public QsciLexerJSON { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerJSON_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerJSON_virtualbase_autoCompletionWordSeparators(const void* self); @@ -992,8 +992,8 @@ bool QsciLexerJSON_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerJSON_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerJSON::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1004,7 +1004,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerJSON_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerlua.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerlua.cpp index eb85412f8a..fbfa3362f6 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerlua.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerlua.cpp @@ -157,14 +157,14 @@ class MiqtVirtualQsciLexerLua final : public QsciLexerLua { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerLua_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerLua_virtualbase_autoCompletionWordSeparators(const void* self); @@ -845,8 +845,8 @@ const char* QsciLexerLua_lexer(const QsciLexerLua* self) { struct miqt_array /* of struct miqt_string */ QsciLexerLua_autoCompletionWordSeparators(const QsciLexerLua* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -857,7 +857,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerLua_autoCompletionWordSe _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1040,8 +1040,8 @@ bool QsciLexerLua_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerLua_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerLua::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1052,7 +1052,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerLua_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexermakefile.cpp b/qt-restricted-extras/qscintilla/gen_qscilexermakefile.cpp index eb557f15ba..f6bab16941 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexermakefile.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexermakefile.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerMakefile final : public QsciLexerMakefile { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerMakefile_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerMakefile_virtualbase_autoCompletionWordSeparators(const void* self); @@ -962,8 +962,8 @@ bool QsciLexerMakefile_override_virtual_autoCompletionWordSeparators(void* self, struct miqt_array /* of struct miqt_string */ QsciLexerMakefile_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerMakefile::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -974,7 +974,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerMakefile_virtualbase_aut _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexermarkdown.cpp b/qt-restricted-extras/qscintilla/gen_qscilexermarkdown.cpp index 7a26f17aca..ce0154ad9c 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexermarkdown.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexermarkdown.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerMarkdown final : public QsciLexerMarkdown { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerMarkdown_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerMarkdown_virtualbase_autoCompletionWordSeparators(const void* self); @@ -954,8 +954,8 @@ bool QsciLexerMarkdown_override_virtual_autoCompletionWordSeparators(void* self, struct miqt_array /* of struct miqt_string */ QsciLexerMarkdown_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerMarkdown::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -966,7 +966,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerMarkdown_virtualbase_aut _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexermatlab.cpp b/qt-restricted-extras/qscintilla/gen_qscilexermatlab.cpp index 428361e3c6..7b7945e1b7 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexermatlab.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexermatlab.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerMatlab final : public QsciLexerMatlab { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerMatlab_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerMatlab_virtualbase_autoCompletionWordSeparators(const void* self); @@ -954,8 +954,8 @@ bool QsciLexerMatlab_override_virtual_autoCompletionWordSeparators(void* self, i struct miqt_array /* of struct miqt_string */ QsciLexerMatlab_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerMatlab::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -966,7 +966,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerMatlab_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexeroctave.cpp b/qt-restricted-extras/qscintilla/gen_qscilexeroctave.cpp index 631c71d1cc..dfeb79f5c8 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexeroctave.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexeroctave.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerOctave final : public QsciLexerOctave { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerOctave_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerOctave_virtualbase_autoCompletionWordSeparators(const void* self); @@ -935,8 +935,8 @@ bool QsciLexerOctave_override_virtual_autoCompletionWordSeparators(void* self, i struct miqt_array /* of struct miqt_string */ QsciLexerOctave_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerOctave::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -947,7 +947,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerOctave_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerpascal.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerpascal.cpp index 64cf4fba81..c34115e0de 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerpascal.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerpascal.cpp @@ -193,14 +193,14 @@ class MiqtVirtualQsciLexerPascal final : public QsciLexerPascal { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPascal_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerPascal_virtualbase_autoCompletionWordSeparators(const void* self); @@ -881,8 +881,8 @@ const char* QsciLexerPascal_lexer(const QsciLexerPascal* self) { struct miqt_array /* of struct miqt_string */ QsciLexerPascal_autoCompletionWordSeparators(const QsciLexerPascal* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -893,7 +893,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPascal_autoCompletionWor _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1144,8 +1144,8 @@ bool QsciLexerPascal_override_virtual_autoCompletionWordSeparators(void* self, i struct miqt_array /* of struct miqt_string */ QsciLexerPascal_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerPascal::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1156,7 +1156,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPascal_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerperl.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerperl.cpp index 689d87236d..c2edecb845 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerperl.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerperl.cpp @@ -175,14 +175,14 @@ class MiqtVirtualQsciLexerPerl final : public QsciLexerPerl { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPerl_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerPerl_virtualbase_autoCompletionWordSeparators(const void* self); @@ -863,8 +863,8 @@ const char* QsciLexerPerl_lexer(const QsciLexerPerl* self) { struct miqt_array /* of struct miqt_string */ QsciLexerPerl_autoCompletionWordSeparators(const QsciLexerPerl* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -875,7 +875,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPerl_autoCompletionWordS _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1116,8 +1116,8 @@ bool QsciLexerPerl_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerPerl_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerPerl::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1128,7 +1128,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPerl_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerpo.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerpo.cpp index 899a209fe3..c99ddb2734 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerpo.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerpo.cpp @@ -175,14 +175,14 @@ class MiqtVirtualQsciLexerPO final : public QsciLexerPO { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPO_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerPO_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1036,8 +1036,8 @@ bool QsciLexerPO_override_virtual_autoCompletionWordSeparators(void* self, intpt struct miqt_array /* of struct miqt_string */ QsciLexerPO_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerPO::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1048,7 +1048,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPO_virtualbase_autoCompl _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerpostscript.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerpostscript.cpp index 6e20d75e1c..4701e26395 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerpostscript.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerpostscript.cpp @@ -211,14 +211,14 @@ class MiqtVirtualQsciLexerPostScript final : public QsciLexerPostScript { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPostScript_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerPostScript_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1128,8 +1128,8 @@ bool QsciLexerPostScript_override_virtual_autoCompletionWordSeparators(void* sel struct miqt_array /* of struct miqt_string */ QsciLexerPostScript_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerPostScript::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1140,7 +1140,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPostScript_virtualbase_a _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerpov.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerpov.cpp index ba6c8f703c..f3f9a738e9 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerpov.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerpov.cpp @@ -193,14 +193,14 @@ class MiqtVirtualQsciLexerPOV final : public QsciLexerPOV { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPOV_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerPOV_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1096,8 +1096,8 @@ bool QsciLexerPOV_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerPOV_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerPOV::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1108,7 +1108,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPOV_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerproperties.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerproperties.cpp index 903018a93b..2aa268f438 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerproperties.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerproperties.cpp @@ -157,14 +157,14 @@ class MiqtVirtualQsciLexerProperties final : public QsciLexerProperties { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerProperties_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerProperties_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1016,8 +1016,8 @@ bool QsciLexerProperties_override_virtual_autoCompletionWordSeparators(void* sel struct miqt_array /* of struct miqt_string */ QsciLexerProperties_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerProperties::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1028,7 +1028,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerProperties_virtualbase_a _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerpython.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerpython.cpp index 90af7517d7..156b5e990d 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerpython.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerpython.cpp @@ -209,14 +209,14 @@ class MiqtVirtualQsciLexerPython final : public QsciLexerPython { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPython_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerPython_virtualbase_autoCompletionWordSeparators(const void* self); @@ -882,8 +882,8 @@ const char* QsciLexerPython_lexer(const QsciLexerPython* self) { struct miqt_array /* of struct miqt_string */ QsciLexerPython_autoCompletionWordSeparators(const QsciLexerPython* self) { QStringList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -894,7 +894,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPython_autoCompletionWor _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1192,8 +1192,8 @@ bool QsciLexerPython_override_virtual_autoCompletionWordSeparators(void* self, i struct miqt_array /* of struct miqt_string */ QsciLexerPython_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerPython::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1204,7 +1204,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPython_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerruby.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerruby.cpp index 6a85e68fc9..8ff13136ba 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerruby.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerruby.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerRuby final : public QsciLexerRuby { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerRuby_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerRuby_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1012,8 +1012,8 @@ bool QsciLexerRuby_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerRuby_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerRuby::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1024,7 +1024,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerRuby_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerspice.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerspice.cpp index 21fc2f1bc5..7a3de090d4 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerspice.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerspice.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerSpice final : public QsciLexerSpice { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerSpice_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerSpice_virtualbase_autoCompletionWordSeparators(const void* self); @@ -958,8 +958,8 @@ bool QsciLexerSpice_override_virtual_autoCompletionWordSeparators(void* self, in struct miqt_array /* of struct miqt_string */ QsciLexerSpice_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerSpice::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -970,7 +970,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerSpice_virtualbase_autoCo _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexersql.cpp b/qt-restricted-extras/qscintilla/gen_qscilexersql.cpp index fdc77d8b22..4524bb2053 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexersql.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexersql.cpp @@ -193,14 +193,14 @@ class MiqtVirtualQsciLexerSQL final : public QsciLexerSQL { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerSQL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerSQL_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1132,8 +1132,8 @@ bool QsciLexerSQL_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerSQL_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerSQL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1144,7 +1144,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerSQL_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexertcl.cpp b/qt-restricted-extras/qscintilla/gen_qscilexertcl.cpp index d81c694449..03559eadb0 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexertcl.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexertcl.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerTCL final : public QsciLexerTCL { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerTCL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerTCL_virtualbase_autoCompletionWordSeparators(const void* self); @@ -980,8 +980,8 @@ bool QsciLexerTCL_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerTCL_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerTCL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -992,7 +992,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerTCL_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexertex.cpp b/qt-restricted-extras/qscintilla/gen_qscilexertex.cpp index 121857a26c..60462ff9a7 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexertex.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexertex.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerTeX final : public QsciLexerTeX { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerTeX_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerTeX_virtualbase_autoCompletionWordSeparators(const void* self); @@ -992,8 +992,8 @@ bool QsciLexerTeX_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerTeX_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerTeX::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1004,7 +1004,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerTeX_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerverilog.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerverilog.cpp index 874e845d30..bf4595d9f9 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerverilog.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerverilog.cpp @@ -139,14 +139,14 @@ class MiqtVirtualQsciLexerVerilog final : public QsciLexerVerilog { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerVerilog_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerVerilog_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1016,8 +1016,8 @@ bool QsciLexerVerilog_override_virtual_autoCompletionWordSeparators(void* self, struct miqt_array /* of struct miqt_string */ QsciLexerVerilog_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerVerilog::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1028,7 +1028,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerVerilog_virtualbase_auto _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexervhdl.cpp b/qt-restricted-extras/qscintilla/gen_qscilexervhdl.cpp index 13a25be0ea..14c3c952d0 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexervhdl.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexervhdl.cpp @@ -229,14 +229,14 @@ class MiqtVirtualQsciLexerVHDL final : public QsciLexerVHDL { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerVHDL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerVHDL_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1172,8 +1172,8 @@ bool QsciLexerVHDL_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerVHDL_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerVHDL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1184,7 +1184,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerVHDL_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexerxml.cpp b/qt-restricted-extras/qscintilla/gen_qscilexerxml.cpp index 386c6c09c5..c1a7280cc5 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexerxml.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexerxml.cpp @@ -193,14 +193,14 @@ class MiqtVirtualQsciLexerXML final : public QsciLexerXML { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerXML_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerXML_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1061,8 +1061,8 @@ bool QsciLexerXML_override_virtual_autoCompletionWordSeparators(void* self, intp struct miqt_array /* of struct miqt_string */ QsciLexerXML_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerXML::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1073,7 +1073,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerXML_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qscilexeryaml.cpp b/qt-restricted-extras/qscintilla/gen_qscilexeryaml.cpp index 965ac77aa1..eb8d45d75e 100644 --- a/qt-restricted-extras/qscintilla/gen_qscilexeryaml.cpp +++ b/qt-restricted-extras/qscintilla/gen_qscilexeryaml.cpp @@ -157,14 +157,14 @@ class MiqtVirtualQsciLexerYAML final : public QsciLexerYAML { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerYAML_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciLexerYAML_virtualbase_autoCompletionWordSeparators(const void* self); @@ -1008,8 +1008,8 @@ bool QsciLexerYAML_override_virtual_autoCompletionWordSeparators(void* self, int struct miqt_array /* of struct miqt_string */ QsciLexerYAML_virtualbase_autoCompletionWordSeparators(const void* self) { QStringList _ret = static_cast(self)->QsciLexerYAML::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1020,7 +1020,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerYAML_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla/gen_qsciscintilla.cpp b/qt-restricted-extras/qscintilla/gen_qsciscintilla.cpp index 45d2d342c8..cf011c1de7 100644 --- a/qt-restricted-extras/qscintilla/gen_qsciscintilla.cpp +++ b/qt-restricted-extras/qscintilla/gen_qsciscintilla.cpp @@ -226,14 +226,14 @@ class MiqtVirtualQsciScintilla final : public QsciScintilla { int* sigval2 = &context_start; int* sigval3 = &last_word_start; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciScintilla_apiContext(this, handle__apiContext, sigval1, sigval2, sigval3); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QsciScintilla_virtualbase_apiContext(void* self, int pos, int* context_start, int* last_word_start); @@ -2713,8 +2713,8 @@ struct miqt_string QsciScintilla_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QsciScintilla_apiContext(QsciScintilla* self, int pos, int* context_start, int* last_word_start) { QStringList _ret = self->apiContext(static_cast(pos), static_cast(*context_start), static_cast(*last_word_start)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2725,7 +2725,7 @@ struct miqt_array /* of struct miqt_string */ QsciScintilla_apiContext(QsciScin _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2865,12 +2865,12 @@ QColor* QsciScintilla_color(const QsciScintilla* self) { struct miqt_array /* of int */ QsciScintilla_contractedFolds(const QsciScintilla* self) { QList _ret = self->contractedFolds(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3199,14 +3199,14 @@ void QsciScintilla_setAutoCompletionFillups(QsciScintilla* self, const char* fil } void QsciScintilla_setAutoCompletionWordSeparators(QsciScintilla* self, struct miqt_array /* of struct miqt_string */ separators) { - QStringList separators_QList; - separators_QList.reserve(separators.len); + QStringList separators_QStringList; + separators_QStringList.reserve(separators.len); struct miqt_string* separators_arr = static_cast(separators.data); for(size_t i = 0; i < separators.len; ++i) { QString separators_arr_i_QString = QString::fromUtf8(separators_arr[i].data, separators_arr[i].len); - separators_QList.push_back(separators_arr_i_QString); + separators_QStringList.push_back(separators_arr_i_QString); } - self->setAutoCompletionWordSeparators(separators_QList); + self->setAutoCompletionWordSeparators(separators_QStringList); } void QsciScintilla_setCallTipsBackgroundColor(QsciScintilla* self, QColor* col) { @@ -3445,14 +3445,14 @@ void QsciScintilla_setWrapIndentMode(QsciScintilla* self, int mode) { } void QsciScintilla_showUserList(QsciScintilla* self, int id, struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; - list_QList.reserve(list.len); + QStringList list_QStringList; + list_QStringList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { QString list_arr_i_QString = QString::fromUtf8(list_arr[i].data, list_arr[i].len); - list_QList.push_back(list_arr_i_QString); + list_QStringList.push_back(list_arr_i_QString); } - self->showUserList(static_cast(id), list_QList); + self->showUserList(static_cast(id), list_QStringList); } QsciCommandSet* QsciScintilla_standardCommands(const QsciScintilla* self) { @@ -4151,8 +4151,8 @@ bool QsciScintilla_override_virtual_apiContext(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QsciScintilla_virtualbase_apiContext(void* self, int pos, int* context_start, int* last_word_start) { QStringList _ret = static_cast(self)->QsciScintilla::apiContext(static_cast(pos), static_cast(*context_start), static_cast(*last_word_start)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -4163,7 +4163,7 @@ struct miqt_array /* of struct miqt_string */ QsciScintilla_virtualbase_apiCont _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qsciabstractapis.cpp b/qt-restricted-extras/qscintilla6/gen_qsciabstractapis.cpp index 9da4c556f2..5d032efbb3 100644 --- a/qt-restricted-extras/qscintilla6/gen_qsciabstractapis.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qsciabstractapis.cpp @@ -40,15 +40,15 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { intptr_t handle__updateAutoCompletionList = 0; // Subclass to allow providing a Go implementation - virtual void updateAutoCompletionList(const QStringList& context, QStringList& list) override { + virtual void updateAutoCompletionList(const QList& context, QList& list) override { if (handle__updateAutoCompletionList == 0) { return; // Pure virtual, there is no base we can call } - const QStringList& context_ret = context; + const QList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -59,13 +59,13 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; - QStringList& list_ret = list; + QList& list_ret = list; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.length())); - for (size_t i = 0, e = list_ret.length(); i < e; ++i) { + struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.size())); + for (size_t i = 0, e = list_ret.size(); i < e; ++i) { QString list_lv_ret = list_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray list_lv_b = list_lv_ret.toUtf8(); @@ -76,7 +76,7 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { list_arr[i] = list_lv_ms; } struct miqt_array list_out; - list_out.len = list_ret.length(); + list_out.len = list_ret.size(); list_out.data = static_cast(list_arr); struct miqt_array /* of struct miqt_string */ sigval2 = list_out; miqt_exec_callback_QsciAbstractAPIs_updateAutoCompletionList(this, handle__updateAutoCompletionList, sigval1, sigval2); @@ -111,15 +111,15 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { intptr_t handle__callTips = 0; // Subclass to allow providing a Go implementation - virtual QStringList callTips(const QStringList& context, int commas, QsciScintilla::CallTipsStyle style, QList& shifts) override { + virtual QList callTips(const QList& context, int commas, QsciScintilla::CallTipsStyle style, QList& shifts) override { if (handle__callTips == 0) { - return QStringList(); // Pure virtual, there is no base we can call + return QList(); // Pure virtual, there is no base we can call } - const QStringList& context_ret = context; + const QList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -130,7 +130,7 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; int sigval2 = commas; @@ -138,16 +138,16 @@ class MiqtVirtualQsciAbstractAPIs final : public QsciAbstractAPIs { int sigval3 = static_cast(style_ret); QList& shifts_ret = shifts; // Convert QList<> from C++ memory to manually-managed C memory - int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.length())); - for (size_t i = 0, e = shifts_ret.length(); i < e; ++i) { + int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.size())); + for (size_t i = 0, e = shifts_ret.size(); i < e; ++i) { shifts_arr[i] = shifts_ret[i]; } struct miqt_array shifts_out; - shifts_out.len = shifts_ret.length(); + shifts_out.len = shifts_ret.size(); shifts_out.data = static_cast(shifts_arr); struct miqt_array /* of int */ sigval4 = shifts_out; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciAbstractAPIs_callTips(this, handle__callTips, sigval1, sigval2, sigval3, sigval4); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -318,14 +318,14 @@ QsciLexer* QsciAbstractAPIs_lexer(const QsciAbstractAPIs* self) { } void QsciAbstractAPIs_updateAutoCompletionList(QsciAbstractAPIs* self, struct miqt_array /* of struct miqt_string */ context, struct miqt_array /* of struct miqt_string */ list) { - QStringList context_QList; + QList context_QList; context_QList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); context_QList.push_back(context_arr_i_QString); } - QStringList list_QList; + QList list_QList; list_QList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -341,7 +341,7 @@ void QsciAbstractAPIs_autoCompletionSelected(QsciAbstractAPIs* self, struct miqt } struct miqt_array /* of struct miqt_string */ QsciAbstractAPIs_callTips(QsciAbstractAPIs* self, struct miqt_array /* of struct miqt_string */ context, int commas, int style, struct miqt_array /* of int */ shifts) { - QStringList context_QList; + QList context_QList; context_QList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { @@ -354,10 +354,10 @@ struct miqt_array /* of struct miqt_string */ QsciAbstractAPIs_callTips(QsciAbs for(size_t i = 0; i < shifts.len; ++i) { shifts_QList.push_back(static_cast(shifts_arr[i])); } - QStringList _ret = self->callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); + QList _ret = self->callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -368,7 +368,7 @@ struct miqt_array /* of struct miqt_string */ QsciAbstractAPIs_callTips(QsciAbs _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qsciapis.cpp b/qt-restricted-extras/qscintilla6/gen_qsciapis.cpp index 9d87b25ba3..d76513adce 100644 --- a/qt-restricted-extras/qscintilla6/gen_qsciapis.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qsciapis.cpp @@ -43,16 +43,16 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { intptr_t handle__updateAutoCompletionList = 0; // Subclass to allow providing a Go implementation - virtual void updateAutoCompletionList(const QStringList& context, QStringList& list) override { + virtual void updateAutoCompletionList(const QList& context, QList& list) override { if (handle__updateAutoCompletionList == 0) { QsciAPIs::updateAutoCompletionList(context, list); return; } - const QStringList& context_ret = context; + const QList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -63,13 +63,13 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; - QStringList& list_ret = list; + QList& list_ret = list; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.length())); - for (size_t i = 0, e = list_ret.length(); i < e; ++i) { + struct miqt_string* list_arr = static_cast(malloc(sizeof(struct miqt_string) * list_ret.size())); + for (size_t i = 0, e = list_ret.size(); i < e; ++i) { QString list_lv_ret = list_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray list_lv_b = list_lv_ret.toUtf8(); @@ -80,7 +80,7 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { list_arr[i] = list_lv_ms; } struct miqt_array list_out; - list_out.len = list_ret.length(); + list_out.len = list_ret.size(); list_out.data = static_cast(list_arr); struct miqt_array /* of struct miqt_string */ sigval2 = list_out; miqt_exec_callback_QsciAPIs_updateAutoCompletionList(this, handle__updateAutoCompletionList, sigval1, sigval2); @@ -117,15 +117,15 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { intptr_t handle__callTips = 0; // Subclass to allow providing a Go implementation - virtual QStringList callTips(const QStringList& context, int commas, QsciScintilla::CallTipsStyle style, QList& shifts) override { + virtual QList callTips(const QList& context, int commas, QsciScintilla::CallTipsStyle style, QList& shifts) override { if (handle__callTips == 0) { return QsciAPIs::callTips(context, commas, style, shifts); } - const QStringList& context_ret = context; + const QList& context_ret = context; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.length())); - for (size_t i = 0, e = context_ret.length(); i < e; ++i) { + struct miqt_string* context_arr = static_cast(malloc(sizeof(struct miqt_string) * context_ret.size())); + for (size_t i = 0, e = context_ret.size(); i < e; ++i) { QString context_lv_ret = context_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray context_lv_b = context_lv_ret.toUtf8(); @@ -136,7 +136,7 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { context_arr[i] = context_lv_ms; } struct miqt_array context_out; - context_out.len = context_ret.length(); + context_out.len = context_ret.size(); context_out.data = static_cast(context_arr); struct miqt_array /* of struct miqt_string */ sigval1 = context_out; int sigval2 = commas; @@ -144,16 +144,16 @@ class MiqtVirtualQsciAPIs final : public QsciAPIs { int sigval3 = static_cast(style_ret); QList& shifts_ret = shifts; // Convert QList<> from C++ memory to manually-managed C memory - int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.length())); - for (size_t i = 0, e = shifts_ret.length(); i < e; ++i) { + int* shifts_arr = static_cast(malloc(sizeof(int) * shifts_ret.size())); + for (size_t i = 0, e = shifts_ret.size(); i < e; ++i) { shifts_arr[i] = shifts_ret[i]; } struct miqt_array shifts_out; - shifts_out.len = shifts_ret.length(); + shifts_out.len = shifts_ret.size(); shifts_out.data = static_cast(shifts_arr); struct miqt_array /* of int */ sigval4 = shifts_out; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciAPIs_callTips(this, handle__callTips, sigval1, sigval2, sigval3, sigval4); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -372,14 +372,14 @@ bool QsciAPIs_savePrepared(const QsciAPIs* self) { } void QsciAPIs_updateAutoCompletionList(QsciAPIs* self, struct miqt_array /* of struct miqt_string */ context, struct miqt_array /* of struct miqt_string */ list) { - QStringList context_QList; + QList context_QList; context_QList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); context_QList.push_back(context_arr_i_QString); } - QStringList list_QList; + QList list_QList; list_QList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -395,7 +395,7 @@ void QsciAPIs_autoCompletionSelected(QsciAPIs* self, struct miqt_string sel) { } struct miqt_array /* of struct miqt_string */ QsciAPIs_callTips(QsciAPIs* self, struct miqt_array /* of struct miqt_string */ context, int commas, int style, struct miqt_array /* of int */ shifts) { - QStringList context_QList; + QList context_QList; context_QList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { @@ -408,10 +408,10 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_callTips(QsciAPIs* self, for(size_t i = 0; i < shifts.len; ++i) { shifts_QList.push_back(static_cast(shifts_arr[i])); } - QStringList _ret = self->callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); + QList _ret = self->callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -422,7 +422,7 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_callTips(QsciAPIs* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -432,10 +432,10 @@ bool QsciAPIs_event(QsciAPIs* self, QEvent* e) { } struct miqt_array /* of struct miqt_string */ QsciAPIs_installedAPIFiles(const QsciAPIs* self) { - QStringList _ret = self->installedAPIFiles(); + QList _ret = self->installedAPIFiles(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -446,7 +446,7 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_installedAPIFiles(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -529,14 +529,14 @@ bool QsciAPIs_override_virtual_updateAutoCompletionList(void* self, intptr_t slo } void QsciAPIs_virtualbase_updateAutoCompletionList(void* self, struct miqt_array /* of struct miqt_string */ context, struct miqt_array /* of struct miqt_string */ list) { - QStringList context_QList; + QList context_QList; context_QList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { QString context_arr_i_QString = QString::fromUtf8(context_arr[i].data, context_arr[i].len); context_QList.push_back(context_arr_i_QString); } - QStringList list_QList; + QList list_QList; list_QList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -572,7 +572,7 @@ bool QsciAPIs_override_virtual_callTips(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QsciAPIs_virtualbase_callTips(void* self, struct miqt_array /* of struct miqt_string */ context, int commas, int style, struct miqt_array /* of int */ shifts) { - QStringList context_QList; + QList context_QList; context_QList.reserve(context.len); struct miqt_string* context_arr = static_cast(context.data); for(size_t i = 0; i < context.len; ++i) { @@ -585,10 +585,10 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_virtualbase_callTips(voi for(size_t i = 0; i < shifts.len; ++i) { shifts_QList.push_back(static_cast(shifts_arr[i])); } - QStringList _ret = static_cast(self)->QsciAPIs::callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); + QList _ret = static_cast(self)->QsciAPIs::callTips(context_QList, static_cast(commas), static_cast(style), shifts_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -599,7 +599,7 @@ struct miqt_array /* of struct miqt_string */ QsciAPIs_virtualbase_callTips(voi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscicommandset.cpp b/qt-restricted-extras/qscintilla6/gen_qscicommandset.cpp index ff77b56bf6..f12cae01f6 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscicommandset.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscicommandset.cpp @@ -20,14 +20,14 @@ bool QsciCommandSet_writeSettings(QsciCommandSet* self, QSettings* qs) { } struct miqt_array /* of QsciCommand* */ QsciCommandSet_commands(QsciCommandSet* self) { - QList& _ret = self->commands(); + QList& _ret = self->commands(); // Convert QList<> from C++ memory to manually-managed C memory - QsciCommand** _arr = static_cast(malloc(sizeof(QsciCommand*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QsciCommand** _arr = static_cast(malloc(sizeof(QsciCommand*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexer.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexer.cpp index 1ba7cee0d6..1df46ea6f6 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexer.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexer.cpp @@ -138,13 +138,13 @@ class MiqtVirtualQsciLexer final : public QsciLexer { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexer::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexer_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -829,10 +829,10 @@ const char* QsciLexer_autoCompletionFillups(const QsciLexer* self) { } struct miqt_array /* of struct miqt_string */ QsciLexer_autoCompletionWordSeparators(const QsciLexer* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -843,7 +843,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexer_autoCompletionWordSepar _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1166,10 +1166,10 @@ bool QsciLexer_override_virtual_autoCompletionWordSeparators(void* self, intptr_ } struct miqt_array /* of struct miqt_string */ QsciLexer_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexer::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexer::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1180,7 +1180,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexer_virtualbase_autoComplet _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexeravs.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexeravs.cpp index 863c32e415..bcd7b710c3 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexeravs.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexeravs.cpp @@ -169,13 +169,13 @@ class MiqtVirtualQsciLexerAVS final : public QsciLexerAVS { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerAVS::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerAVS_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1013,10 +1013,10 @@ bool QsciLexerAVS_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerAVS_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerAVS::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerAVS::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1027,7 +1027,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerAVS_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerbash.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerbash.cpp index bafcf7a6b3..a10d58dd44 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerbash.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerbash.cpp @@ -169,13 +169,13 @@ class MiqtVirtualQsciLexerBash final : public QsciLexerBash { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerBash::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerBash_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1021,10 +1021,10 @@ bool QsciLexerBash_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerBash_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerBash::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerBash::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1035,7 +1035,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerBash_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerbatch.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerbatch.cpp index 4e69ef6ffa..229e046719 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerbatch.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerbatch.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerBatch final : public QsciLexerBatch { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerBatch::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerBatch_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -935,10 +935,10 @@ bool QsciLexerBatch_override_virtual_autoCompletionWordSeparators(void* self, in } struct miqt_array /* of struct miqt_string */ QsciLexerBatch_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerBatch::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerBatch::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -949,7 +949,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerBatch_virtualbase_autoCo _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexercmake.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexercmake.cpp index c85f00610e..e41caeae4d 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexercmake.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexercmake.cpp @@ -151,13 +151,13 @@ class MiqtVirtualQsciLexerCMake final : public QsciLexerCMake { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerCMake::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCMake_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -969,10 +969,10 @@ bool QsciLexerCMake_override_virtual_autoCompletionWordSeparators(void* self, in } struct miqt_array /* of struct miqt_string */ QsciLexerCMake_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerCMake::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerCMake::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -983,7 +983,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCMake_virtualbase_autoCo _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexercoffeescript.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexercoffeescript.cpp index 1479856b69..b3c02f0d64 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexercoffeescript.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexercoffeescript.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerCoffeeScript final : public QsciLexerCoffeeScript { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerCoffeeScript::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCoffeeScript_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -814,10 +814,10 @@ const char* QsciLexerCoffeeScript_lexer(const QsciLexerCoffeeScript* self) { } struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_autoCompletionWordSeparators(const QsciLexerCoffeeScript* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -828,7 +828,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_autoComplet _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1017,10 +1017,10 @@ bool QsciLexerCoffeeScript_override_virtual_autoCompletionWordSeparators(void* s } struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerCoffeeScript::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerCoffeeScript::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1031,7 +1031,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCoffeeScript_virtualbase _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexercpp.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexercpp.cpp index c47ea7527d..e30a1f2189 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexercpp.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexercpp.cpp @@ -224,13 +224,13 @@ class MiqtVirtualQsciLexerCPP final : public QsciLexerCPP { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerCPP::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCPP_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -909,10 +909,10 @@ const char* QsciLexerCPP_lexer(const QsciLexerCPP* self) { } struct miqt_array /* of struct miqt_string */ QsciLexerCPP_autoCompletionWordSeparators(const QsciLexerCPP* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -923,7 +923,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCPP_autoCompletionWordSe _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1238,10 +1238,10 @@ bool QsciLexerCPP_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerCPP_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerCPP::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerCPP::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1252,7 +1252,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCPP_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexercsharp.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexercsharp.cpp index d63861693e..449accc86d 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexercsharp.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexercsharp.cpp @@ -223,13 +223,13 @@ class MiqtVirtualQsciLexerCSharp final : public QsciLexerCSharp { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerCSharp::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCSharp_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1085,10 +1085,10 @@ bool QsciLexerCSharp_override_virtual_autoCompletionWordSeparators(void* self, i } struct miqt_array /* of struct miqt_string */ QsciLexerCSharp_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerCSharp::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerCSharp::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1099,7 +1099,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCSharp_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexercss.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexercss.cpp index b9a895a85a..253368059f 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexercss.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexercss.cpp @@ -169,13 +169,13 @@ class MiqtVirtualQsciLexerCSS final : public QsciLexerCSS { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerCSS::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCSS_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1049,10 +1049,10 @@ bool QsciLexerCSS_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerCSS_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerCSS::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerCSS::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1063,7 +1063,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCSS_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexercustom.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexercustom.cpp index eadd8a3d4d..26b325569f 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexercustom.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexercustom.cpp @@ -181,13 +181,13 @@ class MiqtVirtualQsciLexerCustom final : public QsciLexerCustom { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerCustom::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerCustom_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -970,10 +970,10 @@ bool QsciLexerCustom_override_virtual_autoCompletionWordSeparators(void* self, i } struct miqt_array /* of struct miqt_string */ QsciLexerCustom_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerCustom::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerCustom::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -984,7 +984,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerCustom_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerd.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerd.cpp index 4acb1b7f27..afd9bdbce3 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerd.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerd.cpp @@ -187,13 +187,13 @@ class MiqtVirtualQsciLexerD final : public QsciLexerD { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerD::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerD_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -868,10 +868,10 @@ const char* QsciLexerD_lexer(const QsciLexerD* self) { } struct miqt_array /* of struct miqt_string */ QsciLexerD_autoCompletionWordSeparators(const QsciLexerD* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -882,7 +882,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerD_autoCompletionWordSepa _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1105,10 +1105,10 @@ bool QsciLexerD_override_virtual_autoCompletionWordSeparators(void* self, intptr } struct miqt_array /* of struct miqt_string */ QsciLexerD_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerD::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerD::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1119,7 +1119,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerD_virtualbase_autoComple _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerdiff.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerdiff.cpp index 9c7d59cf89..74f57d4750 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerdiff.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerdiff.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerDiff final : public QsciLexerDiff { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerDiff::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerDiff_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -915,10 +915,10 @@ bool QsciLexerDiff_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerDiff_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerDiff::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerDiff::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -929,7 +929,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerDiff_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexeredifact.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexeredifact.cpp index 97abdd087d..825b73b5cd 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexeredifact.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexeredifact.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerEDIFACT final : public QsciLexerEDIFACT { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerEDIFACT::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerEDIFACT_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -911,10 +911,10 @@ bool QsciLexerEDIFACT_override_virtual_autoCompletionWordSeparators(void* self, } struct miqt_array /* of struct miqt_string */ QsciLexerEDIFACT_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerEDIFACT::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerEDIFACT::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -925,7 +925,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerEDIFACT_virtualbase_auto _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerfortran.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerfortran.cpp index 6187ecc254..06e9f3dcab 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerfortran.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerfortran.cpp @@ -151,13 +151,13 @@ class MiqtVirtualQsciLexerFortran final : public QsciLexerFortran { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerFortran::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerFortran_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -934,10 +934,10 @@ bool QsciLexerFortran_override_virtual_autoCompletionWordSeparators(void* self, } struct miqt_array /* of struct miqt_string */ QsciLexerFortran_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerFortran::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerFortran::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -948,7 +948,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerFortran_virtualbase_auto _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerfortran77.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerfortran77.cpp index 100f7cb8f4..bb33dcea71 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerfortran77.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerfortran77.cpp @@ -151,13 +151,13 @@ class MiqtVirtualQsciLexerFortran77 final : public QsciLexerFortran77 { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerFortran77::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerFortran77_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -977,10 +977,10 @@ bool QsciLexerFortran77_override_virtual_autoCompletionWordSeparators(void* self } struct miqt_array /* of struct miqt_string */ QsciLexerFortran77_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerFortran77::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerFortran77::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -991,7 +991,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerFortran77_virtualbase_au _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerhtml.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerhtml.cpp index 1dbe21bc07..e7df08270e 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerhtml.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerhtml.cpp @@ -187,13 +187,13 @@ class MiqtVirtualQsciLexerHTML final : public QsciLexerHTML { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerHTML::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerHTML_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1093,10 +1093,10 @@ bool QsciLexerHTML_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerHTML_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerHTML::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerHTML::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1107,7 +1107,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerHTML_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexeridl.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexeridl.cpp index 4f0f990ad1..6939b0f1fb 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexeridl.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexeridl.cpp @@ -223,13 +223,13 @@ class MiqtVirtualQsciLexerIDL final : public QsciLexerIDL { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerIDL::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerIDL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1073,10 +1073,10 @@ bool QsciLexerIDL_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerIDL_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerIDL::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerIDL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1087,7 +1087,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerIDL_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerjava.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerjava.cpp index f8086bfeb1..d3595d5e97 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerjava.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerjava.cpp @@ -223,13 +223,13 @@ class MiqtVirtualQsciLexerJava final : public QsciLexerJava { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerJava::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerJava_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1058,10 +1058,10 @@ bool QsciLexerJava_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerJava_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerJava::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerJava::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1072,7 +1072,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerJava_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerjavascript.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerjavascript.cpp index 99826ba7a1..0f8784acdb 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerjavascript.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerjavascript.cpp @@ -223,13 +223,13 @@ class MiqtVirtualQsciLexerJavaScript final : public QsciLexerJavaScript { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerJavaScript::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerJavaScript_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1085,10 +1085,10 @@ bool QsciLexerJavaScript_override_virtual_autoCompletionWordSeparators(void* sel } struct miqt_array /* of struct miqt_string */ QsciLexerJavaScript_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerJavaScript::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerJavaScript::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1099,7 +1099,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerJavaScript_virtualbase_a _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerjson.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerjson.cpp index c569a5610a..679baae3c2 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerjson.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerjson.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerJSON final : public QsciLexerJSON { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerJSON::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerJSON_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -957,10 +957,10 @@ bool QsciLexerJSON_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerJSON_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerJSON::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerJSON::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -971,7 +971,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerJSON_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerlua.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerlua.cpp index 02f2e36207..6e556208a5 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerlua.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerlua.cpp @@ -151,13 +151,13 @@ class MiqtVirtualQsciLexerLua final : public QsciLexerLua { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerLua::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerLua_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -832,10 +832,10 @@ const char* QsciLexerLua_lexer(const QsciLexerLua* self) { } struct miqt_array /* of struct miqt_string */ QsciLexerLua_autoCompletionWordSeparators(const QsciLexerLua* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -846,7 +846,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerLua_autoCompletionWordSe _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1005,10 +1005,10 @@ bool QsciLexerLua_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerLua_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerLua::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerLua::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1019,7 +1019,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerLua_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexermakefile.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexermakefile.cpp index fdae9eb6cb..6059074aa8 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexermakefile.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexermakefile.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerMakefile final : public QsciLexerMakefile { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerMakefile::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerMakefile_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -927,10 +927,10 @@ bool QsciLexerMakefile_override_virtual_autoCompletionWordSeparators(void* self, } struct miqt_array /* of struct miqt_string */ QsciLexerMakefile_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerMakefile::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerMakefile::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -941,7 +941,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerMakefile_virtualbase_aut _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexermarkdown.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexermarkdown.cpp index 1d0442f220..9a34eb55f6 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexermarkdown.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexermarkdown.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerMarkdown final : public QsciLexerMarkdown { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerMarkdown::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerMarkdown_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -919,10 +919,10 @@ bool QsciLexerMarkdown_override_virtual_autoCompletionWordSeparators(void* self, } struct miqt_array /* of struct miqt_string */ QsciLexerMarkdown_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerMarkdown::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerMarkdown::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -933,7 +933,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerMarkdown_virtualbase_aut _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexermatlab.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexermatlab.cpp index 3fed50cca1..62c2641321 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexermatlab.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexermatlab.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerMatlab final : public QsciLexerMatlab { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerMatlab::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerMatlab_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -919,10 +919,10 @@ bool QsciLexerMatlab_override_virtual_autoCompletionWordSeparators(void* self, i } struct miqt_array /* of struct miqt_string */ QsciLexerMatlab_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerMatlab::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerMatlab::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -933,7 +933,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerMatlab_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexeroctave.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexeroctave.cpp index 3f2f7e7439..b5f660d666 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexeroctave.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexeroctave.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerOctave final : public QsciLexerOctave { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerOctave::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerOctave_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -900,10 +900,10 @@ bool QsciLexerOctave_override_virtual_autoCompletionWordSeparators(void* self, i } struct miqt_array /* of struct miqt_string */ QsciLexerOctave_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerOctave::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerOctave::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -914,7 +914,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerOctave_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerpascal.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerpascal.cpp index 18f28a7279..aac2d6d063 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerpascal.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerpascal.cpp @@ -187,13 +187,13 @@ class MiqtVirtualQsciLexerPascal final : public QsciLexerPascal { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerPascal::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPascal_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -868,10 +868,10 @@ const char* QsciLexerPascal_lexer(const QsciLexerPascal* self) { } struct miqt_array /* of struct miqt_string */ QsciLexerPascal_autoCompletionWordSeparators(const QsciLexerPascal* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -882,7 +882,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPascal_autoCompletionWor _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1109,10 +1109,10 @@ bool QsciLexerPascal_override_virtual_autoCompletionWordSeparators(void* self, i } struct miqt_array /* of struct miqt_string */ QsciLexerPascal_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerPascal::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerPascal::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1123,7 +1123,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPascal_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerperl.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerperl.cpp index 453148303f..2adc9c5a07 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerperl.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerperl.cpp @@ -169,13 +169,13 @@ class MiqtVirtualQsciLexerPerl final : public QsciLexerPerl { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerPerl::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPerl_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -850,10 +850,10 @@ const char* QsciLexerPerl_lexer(const QsciLexerPerl* self) { } struct miqt_array /* of struct miqt_string */ QsciLexerPerl_autoCompletionWordSeparators(const QsciLexerPerl* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -864,7 +864,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPerl_autoCompletionWordS _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1081,10 +1081,10 @@ bool QsciLexerPerl_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerPerl_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerPerl::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerPerl::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1095,7 +1095,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPerl_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerpo.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerpo.cpp index 72936e063c..d94788b46a 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerpo.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerpo.cpp @@ -169,13 +169,13 @@ class MiqtVirtualQsciLexerPO final : public QsciLexerPO { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerPO::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPO_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1001,10 +1001,10 @@ bool QsciLexerPO_override_virtual_autoCompletionWordSeparators(void* self, intpt } struct miqt_array /* of struct miqt_string */ QsciLexerPO_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerPO::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerPO::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1015,7 +1015,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPO_virtualbase_autoCompl _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerpostscript.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerpostscript.cpp index 36e3a370c9..6426a415d4 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerpostscript.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerpostscript.cpp @@ -205,13 +205,13 @@ class MiqtVirtualQsciLexerPostScript final : public QsciLexerPostScript { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerPostScript::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPostScript_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1093,10 +1093,10 @@ bool QsciLexerPostScript_override_virtual_autoCompletionWordSeparators(void* sel } struct miqt_array /* of struct miqt_string */ QsciLexerPostScript_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerPostScript::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerPostScript::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1107,7 +1107,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPostScript_virtualbase_a _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerpov.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerpov.cpp index c05c582641..0b40eccb43 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerpov.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerpov.cpp @@ -187,13 +187,13 @@ class MiqtVirtualQsciLexerPOV final : public QsciLexerPOV { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerPOV::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPOV_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1061,10 +1061,10 @@ bool QsciLexerPOV_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerPOV_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerPOV::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerPOV::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1075,7 +1075,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPOV_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerproperties.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerproperties.cpp index 3694063b19..258a996c19 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerproperties.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerproperties.cpp @@ -151,13 +151,13 @@ class MiqtVirtualQsciLexerProperties final : public QsciLexerProperties { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerProperties::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerProperties_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -981,10 +981,10 @@ bool QsciLexerProperties_override_virtual_autoCompletionWordSeparators(void* sel } struct miqt_array /* of struct miqt_string */ QsciLexerProperties_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerProperties::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerProperties::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -995,7 +995,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerProperties_virtualbase_a _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerpython.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerpython.cpp index 489aa10008..3495977b86 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerpython.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerpython.cpp @@ -203,13 +203,13 @@ class MiqtVirtualQsciLexerPython final : public QsciLexerPython { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerPython::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerPython_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -869,10 +869,10 @@ const char* QsciLexerPython_lexer(const QsciLexerPython* self) { } struct miqt_array /* of struct miqt_string */ QsciLexerPython_autoCompletionWordSeparators(const QsciLexerPython* self) { - QStringList _ret = self->autoCompletionWordSeparators(); + QList _ret = self->autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -883,7 +883,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPython_autoCompletionWor _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1157,10 +1157,10 @@ bool QsciLexerPython_override_virtual_autoCompletionWordSeparators(void* self, i } struct miqt_array /* of struct miqt_string */ QsciLexerPython_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerPython::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerPython::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1171,7 +1171,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerPython_virtualbase_autoC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerruby.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerruby.cpp index 6fa56ad168..f54dd9e7f6 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerruby.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerruby.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerRuby final : public QsciLexerRuby { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerRuby::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerRuby_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -977,10 +977,10 @@ bool QsciLexerRuby_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerRuby_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerRuby::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerRuby::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -991,7 +991,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerRuby_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerspice.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerspice.cpp index f333afd6bf..2a2b2eff73 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerspice.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerspice.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerSpice final : public QsciLexerSpice { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerSpice::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerSpice_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -923,10 +923,10 @@ bool QsciLexerSpice_override_virtual_autoCompletionWordSeparators(void* self, in } struct miqt_array /* of struct miqt_string */ QsciLexerSpice_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerSpice::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerSpice::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -937,7 +937,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerSpice_virtualbase_autoCo _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexersql.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexersql.cpp index 76fbcafeb6..ccc7c24d60 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexersql.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexersql.cpp @@ -187,13 +187,13 @@ class MiqtVirtualQsciLexerSQL final : public QsciLexerSQL { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerSQL::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerSQL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1097,10 +1097,10 @@ bool QsciLexerSQL_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerSQL_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerSQL::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerSQL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1111,7 +1111,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerSQL_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexertcl.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexertcl.cpp index fca619004f..d2a5958eea 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexertcl.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexertcl.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerTCL final : public QsciLexerTCL { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerTCL::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerTCL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -945,10 +945,10 @@ bool QsciLexerTCL_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerTCL_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerTCL::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerTCL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -959,7 +959,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerTCL_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexertex.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexertex.cpp index 5b084b173d..0082a26c8c 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexertex.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexertex.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerTeX final : public QsciLexerTeX { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerTeX::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerTeX_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -957,10 +957,10 @@ bool QsciLexerTeX_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerTeX_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerTeX::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerTeX::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -971,7 +971,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerTeX_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerverilog.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerverilog.cpp index 93d2267823..26e311e65a 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerverilog.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerverilog.cpp @@ -133,13 +133,13 @@ class MiqtVirtualQsciLexerVerilog final : public QsciLexerVerilog { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerVerilog::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerVerilog_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -981,10 +981,10 @@ bool QsciLexerVerilog_override_virtual_autoCompletionWordSeparators(void* self, } struct miqt_array /* of struct miqt_string */ QsciLexerVerilog_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerVerilog::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerVerilog::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -995,7 +995,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerVerilog_virtualbase_auto _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexervhdl.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexervhdl.cpp index 34416c751a..67159f5ac2 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexervhdl.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexervhdl.cpp @@ -223,13 +223,13 @@ class MiqtVirtualQsciLexerVHDL final : public QsciLexerVHDL { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerVHDL::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerVHDL_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1137,10 +1137,10 @@ bool QsciLexerVHDL_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerVHDL_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerVHDL::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerVHDL::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1151,7 +1151,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerVHDL_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexerxml.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexerxml.cpp index 024de6894c..f9b36634e7 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexerxml.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexerxml.cpp @@ -187,13 +187,13 @@ class MiqtVirtualQsciLexerXML final : public QsciLexerXML { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerXML::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerXML_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1026,10 +1026,10 @@ bool QsciLexerXML_override_virtual_autoCompletionWordSeparators(void* self, intp } struct miqt_array /* of struct miqt_string */ QsciLexerXML_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerXML::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerXML::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1040,7 +1040,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerXML_virtualbase_autoComp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qscilexeryaml.cpp b/qt-restricted-extras/qscintilla6/gen_qscilexeryaml.cpp index 0df581a7dd..e2d7c1f0a3 100644 --- a/qt-restricted-extras/qscintilla6/gen_qscilexeryaml.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qscilexeryaml.cpp @@ -151,13 +151,13 @@ class MiqtVirtualQsciLexerYAML final : public QsciLexerYAML { intptr_t handle__autoCompletionWordSeparators = 0; // Subclass to allow providing a Go implementation - virtual QStringList autoCompletionWordSeparators() const override { + virtual QList autoCompletionWordSeparators() const override { if (handle__autoCompletionWordSeparators == 0) { return QsciLexerYAML::autoCompletionWordSeparators(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerYAML_autoCompletionWordSeparators(this, handle__autoCompletionWordSeparators); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -973,10 +973,10 @@ bool QsciLexerYAML_override_virtual_autoCompletionWordSeparators(void* self, int } struct miqt_array /* of struct miqt_string */ QsciLexerYAML_virtualbase_autoCompletionWordSeparators(const void* self) { - QStringList _ret = static_cast(self)->QsciLexerYAML::autoCompletionWordSeparators(); + QList _ret = static_cast(self)->QsciLexerYAML::autoCompletionWordSeparators(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -987,7 +987,7 @@ struct miqt_array /* of struct miqt_string */ QsciLexerYAML_virtualbase_autoCom _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt-restricted-extras/qscintilla6/gen_qsciscintilla.cpp b/qt-restricted-extras/qscintilla6/gen_qsciscintilla.cpp index 31c5403096..baac7d8ec1 100644 --- a/qt-restricted-extras/qscintilla6/gen_qsciscintilla.cpp +++ b/qt-restricted-extras/qscintilla6/gen_qsciscintilla.cpp @@ -219,7 +219,7 @@ class MiqtVirtualQsciScintilla final : public QsciScintilla { intptr_t handle__apiContext = 0; // Subclass to allow providing a Go implementation - virtual QStringList apiContext(int pos, int& context_start, int& last_word_start) override { + virtual QList apiContext(int pos, int& context_start, int& last_word_start) override { if (handle__apiContext == 0) { return QsciScintilla::apiContext(pos, context_start, last_word_start); } @@ -228,7 +228,7 @@ class MiqtVirtualQsciScintilla final : public QsciScintilla { int* sigval2 = &context_start; int* sigval3 = &last_word_start; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciScintilla_apiContext(this, handle__apiContext, sigval1, sigval2, sigval3); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -2719,10 +2719,10 @@ struct miqt_string QsciScintilla_tr(const char* s) { } struct miqt_array /* of struct miqt_string */ QsciScintilla_apiContext(QsciScintilla* self, int pos, int* context_start, int* last_word_start) { - QStringList _ret = self->apiContext(static_cast(pos), static_cast(*context_start), static_cast(*last_word_start)); + QList _ret = self->apiContext(static_cast(pos), static_cast(*context_start), static_cast(*last_word_start)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2733,7 +2733,7 @@ struct miqt_array /* of struct miqt_string */ QsciScintilla_apiContext(QsciScin _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2873,12 +2873,12 @@ QColor* QsciScintilla_color(const QsciScintilla* self) { struct miqt_array /* of int */ QsciScintilla_contractedFolds(const QsciScintilla* self) { QList _ret = self->contractedFolds(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3207,7 +3207,7 @@ void QsciScintilla_setAutoCompletionFillups(QsciScintilla* self, const char* fil } void QsciScintilla_setAutoCompletionWordSeparators(QsciScintilla* self, struct miqt_array /* of struct miqt_string */ separators) { - QStringList separators_QList; + QList separators_QList; separators_QList.reserve(separators.len); struct miqt_string* separators_arr = static_cast(separators.data); for(size_t i = 0; i < separators.len; ++i) { @@ -3453,7 +3453,7 @@ void QsciScintilla_setWrapIndentMode(QsciScintilla* self, int mode) { } void QsciScintilla_showUserList(QsciScintilla* self, int id, struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; + QList list_QList; list_QList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -4135,10 +4135,10 @@ bool QsciScintilla_override_virtual_apiContext(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QsciScintilla_virtualbase_apiContext(void* self, int pos, int* context_start, int* last_word_start) { - QStringList _ret = static_cast(self)->QsciScintilla::apiContext(static_cast(pos), static_cast(*context_start), static_cast(*last_word_start)); + QList _ret = static_cast(self)->QsciScintilla::apiContext(static_cast(pos), static_cast(*context_start), static_cast(*last_word_start)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -4149,7 +4149,7 @@ struct miqt_array /* of struct miqt_string */ QsciScintilla_virtualbase_apiCont _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/cbor/gen_qcborarray.cpp b/qt/cbor/gen_qcborarray.cpp index 60be869b1e..c11556b5ee 100644 --- a/qt/cbor/gen_qcborarray.cpp +++ b/qt/cbor/gen_qcborarray.cpp @@ -230,24 +230,24 @@ QCborArray* QCborArray_operatorShiftLeft(QCborArray* self, QCborValue* v) { } QCborArray* QCborArray_fromStringList(struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; - list_QList.reserve(list.len); + QStringList list_QStringList; + list_QStringList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { QString list_arr_i_QString = QString::fromUtf8(list_arr[i].data, list_arr[i].len); - list_QList.push_back(list_arr_i_QString); + list_QStringList.push_back(list_arr_i_QString); } - return new QCborArray(QCborArray::fromStringList(list_QList)); + return new QCborArray(QCborArray::fromStringList(list_QStringList)); } QCborArray* QCborArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { - QVariantList list_QList; - list_QList.reserve(list.len); + QVariantList list_QVariantList; + list_QVariantList.reserve(list.len); QVariant** list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { - list_QList.push_back(*(list_arr[i])); + list_QVariantList.push_back(*(list_arr[i])); } - return new QCborArray(QCborArray::fromVariantList(list_QList)); + return new QCborArray(QCborArray::fromVariantList(list_QVariantList)); } QCborArray* QCborArray_fromJsonArray(QJsonArray* array) { @@ -257,12 +257,12 @@ QCborArray* QCborArray_fromJsonArray(QJsonArray* array) { struct miqt_array /* of QVariant* */ QCborArray_toVariantList(const QCborArray* self) { QVariantList _ret = self->toVariantList(); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/cbor/gen_qcbormap.cpp b/qt/cbor/gen_qcbormap.cpp index 5179ae3338..31bf4e9617 100644 --- a/qt/cbor/gen_qcbormap.cpp +++ b/qt/cbor/gen_qcbormap.cpp @@ -59,12 +59,12 @@ void QCborMap_clear(QCborMap* self) { struct miqt_array /* of QCborValue* */ QCborMap_keys(const QCborMap* self) { QVector _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - QCborValue** _arr = static_cast(malloc(sizeof(QCborValue*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCborValue** _arr = static_cast(malloc(sizeof(QCborValue*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCborValue(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qabstracteventdispatcher.cpp b/qt/gen_qabstracteventdispatcher.cpp index 36c9791c79..e4954f60a1 100644 --- a/qt/gen_qabstracteventdispatcher.cpp +++ b/qt/gen_qabstracteventdispatcher.cpp @@ -97,12 +97,12 @@ bool QAbstractEventDispatcher_unregisterTimers(QAbstractEventDispatcher* self, Q struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */ QAbstractEventDispatcher_registeredTimers(const QAbstractEventDispatcher* self, QObject* object) { QList _ret = self->registeredTimers(object); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractEventDispatcher__TimerInfo** _arr = static_cast(malloc(sizeof(QAbstractEventDispatcher__TimerInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractEventDispatcher__TimerInfo** _arr = static_cast(malloc(sizeof(QAbstractEventDispatcher__TimerInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QAbstractEventDispatcher::TimerInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qabstractitemdelegate.cpp b/qt/gen_qabstractitemdelegate.cpp index eaef03c334..bf5bfe50fb 100644 --- a/qt/gen_qabstractitemdelegate.cpp +++ b/qt/gen_qabstractitemdelegate.cpp @@ -259,13 +259,13 @@ class MiqtVirtualQAbstractItemDelegate final : public QAbstractItemDelegate { } struct miqt_array /* of int */ callback_return_value = miqt_exec_callback_QAbstractItemDelegate_paintingRoles(this, handle__paintingRoles); - QVector callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QVector callback_return_value_QVector; + callback_return_value_QVector.reserve(callback_return_value.len); int* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(static_cast(callback_return_value_arr[i])); + callback_return_value_QVector.push_back(static_cast(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QVector; } friend struct miqt_array /* of int */ QAbstractItemDelegate_virtualbase_paintingRoles(const void* self); @@ -492,12 +492,12 @@ bool QAbstractItemDelegate_helpEvent(QAbstractItemDelegate* self, QHelpEvent* ev struct miqt_array /* of int */ QAbstractItemDelegate_paintingRoles(const QAbstractItemDelegate* self) { QVector _ret = self->paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -725,12 +725,12 @@ bool QAbstractItemDelegate_override_virtual_paintingRoles(void* self, intptr_t s struct miqt_array /* of int */ QAbstractItemDelegate_virtualbase_paintingRoles(const void* self) { QVector _ret = static_cast(self)->QAbstractItemDelegate::paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qabstractitemmodel.cpp b/qt/gen_qabstractitemmodel.cpp index a079e1573e..cd96b5093b 100644 --- a/qt/gen_qabstractitemmodel.cpp +++ b/qt/gen_qabstractitemmodel.cpp @@ -618,14 +618,14 @@ class MiqtVirtualQAbstractItemModel final : public QAbstractItemModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractItemModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QAbstractItemModel_virtualbase_mimeTypes(const void* self); @@ -641,12 +641,12 @@ class MiqtVirtualQAbstractItemModel final : public QAbstractItemModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractItemModel_mimeData(this, handle__mimeData, sigval1); @@ -971,13 +971,13 @@ class MiqtVirtualQAbstractItemModel final : public QAbstractItemModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractItemModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QAbstractItemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -1323,8 +1323,8 @@ bool QAbstractItemModel_setItemData(QAbstractItemModel* self, QModelIndex* index struct miqt_array /* of struct miqt_string */ QAbstractItemModel_mimeTypes(const QAbstractItemModel* self) { QStringList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1335,19 +1335,19 @@ struct miqt_array /* of struct miqt_string */ QAbstractItemModel_mimeTypes(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QAbstractItemModel_mimeData(const QAbstractItemModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return self->mimeData(indexes_QList); + return self->mimeData(indexes_QModelIndexList); } bool QAbstractItemModel_canDropMimeData(const QAbstractItemModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { @@ -1440,12 +1440,12 @@ QModelIndex* QAbstractItemModel_buddy(const QAbstractItemModel* self, QModelInde struct miqt_array /* of QModelIndex* */ QAbstractItemModel_match(const QAbstractItemModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1608,13 +1608,13 @@ bool QAbstractItemModel_checkIndex2(const QAbstractItemModel* self, QModelIndex* } void QAbstractItemModel_dataChanged2(QAbstractItemModel* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - self->dataChanged(*topLeft, *bottomRight, roles_QList); + self->dataChanged(*topLeft, *bottomRight, roles_QVector); } void QAbstractItemModel_connect_dataChanged2(QAbstractItemModel* self, intptr_t slot) { @@ -1627,12 +1627,12 @@ void QAbstractItemModel_connect_dataChanged2(QAbstractItemModel* self, intptr_t QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QAbstractItemModel_dataChanged2(slot, sigval1, sigval2, sigval3); @@ -1653,12 +1653,12 @@ void QAbstractItemModel_connect_layoutChangedWithParents(QAbstractItemModel* sel QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), self, [=](const QList& parents) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; miqt_exec_callback_QAbstractItemModel_layoutChangedWithParents(slot, sigval1); @@ -1679,12 +1679,12 @@ void QAbstractItemModel_connect_layoutChanged2(QAbstractItemModel* self, intptr_ QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), self, [=](const QList& parents, QAbstractItemModel::LayoutChangeHint hint) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; QAbstractItemModel::LayoutChangeHint hint_ret = hint; @@ -1707,12 +1707,12 @@ void QAbstractItemModel_connect_layoutAboutToBeChangedWithParents(QAbstractItemM QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), self, [=](const QList& parents) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; miqt_exec_callback_QAbstractItemModel_layoutAboutToBeChangedWithParents(slot, sigval1); @@ -1733,12 +1733,12 @@ void QAbstractItemModel_connect_layoutAboutToBeChanged2(QAbstractItemModel* self QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), self, [=](const QList& parents, QAbstractItemModel::LayoutChangeHint hint) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; QAbstractItemModel::LayoutChangeHint hint_ret = hint; @@ -1928,8 +1928,8 @@ bool QAbstractItemModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QAbstractItemModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QAbstractItemModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1940,7 +1940,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractItemModel_virtualbase_mi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1956,13 +1956,13 @@ bool QAbstractItemModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractItemModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QAbstractItemModel::mimeData(indexes_QList); + return static_cast(self)->QAbstractItemModel::mimeData(indexes_QModelIndexList); } bool QAbstractItemModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -2191,12 +2191,12 @@ 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) { QModelIndexList _ret = static_cast(self)->QAbstractItemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2415,13 +2415,13 @@ void QAbstractItemModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const v } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QAbstractItemModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2608,19 +2608,19 @@ void QAbstractItemModel_protectedbase_changePersistentIndexList(bool* _dynamic_c } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QAbstractItemModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2633,12 +2633,12 @@ struct miqt_array /* of QModelIndex* */ QAbstractItemModel_protectedbase_persis *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3130,14 +3130,14 @@ class MiqtVirtualQAbstractTableModel final : public QAbstractTableModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractTableModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QAbstractTableModel_virtualbase_mimeTypes(const void* self); @@ -3153,12 +3153,12 @@ class MiqtVirtualQAbstractTableModel final : public QAbstractTableModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractTableModel_mimeData(this, handle__mimeData, sigval1); @@ -3442,13 +3442,13 @@ class MiqtVirtualQAbstractTableModel final : public QAbstractTableModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractTableModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QAbstractTableModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -3968,8 +3968,8 @@ bool QAbstractTableModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QAbstractTableModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QAbstractTableModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -3980,7 +3980,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractTableModel_virtualbase_m _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3996,13 +3996,13 @@ bool QAbstractTableModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractTableModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QAbstractTableModel::mimeData(indexes_QList); + return static_cast(self)->QAbstractTableModel::mimeData(indexes_QModelIndexList); } bool QAbstractTableModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -4202,12 +4202,12 @@ 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) { QModelIndexList _ret = static_cast(self)->QAbstractTableModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -4415,13 +4415,13 @@ void QAbstractTableModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QAbstractTableModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -4608,19 +4608,19 @@ void QAbstractTableModel_protectedbase_changePersistentIndexList(bool* _dynamic_ } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QAbstractTableModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -4633,12 +4633,12 @@ struct miqt_array /* of QModelIndex* */ QAbstractTableModel_protectedbase_persi *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -4943,14 +4943,14 @@ class MiqtVirtualQAbstractListModel final : public QAbstractListModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractListModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QAbstractListModel_virtualbase_mimeTypes(const void* self); @@ -4966,12 +4966,12 @@ class MiqtVirtualQAbstractListModel final : public QAbstractListModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractListModel_mimeData(this, handle__mimeData, sigval1); @@ -5255,13 +5255,13 @@ class MiqtVirtualQAbstractListModel final : public QAbstractListModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractListModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QAbstractListModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -5771,8 +5771,8 @@ bool QAbstractListModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QAbstractListModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QAbstractListModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -5783,7 +5783,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractListModel_virtualbase_mi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -5799,13 +5799,13 @@ bool QAbstractListModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractListModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QAbstractListModel::mimeData(indexes_QList); + return static_cast(self)->QAbstractListModel::mimeData(indexes_QModelIndexList); } bool QAbstractListModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -6005,12 +6005,12 @@ 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) { QModelIndexList _ret = static_cast(self)->QAbstractListModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -6218,13 +6218,13 @@ void QAbstractListModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const v } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QAbstractListModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -6411,19 +6411,19 @@ void QAbstractListModel_protectedbase_changePersistentIndexList(bool* _dynamic_c } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QAbstractListModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -6436,12 +6436,12 @@ struct miqt_array /* of QModelIndex* */ QAbstractListModel_protectedbase_persis *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qabstractitemview.cpp b/qt/gen_qabstractitemview.cpp index ded08625ab..9f92148533 100644 --- a/qt/gen_qabstractitemview.cpp +++ b/qt/gen_qabstractitemview.cpp @@ -405,12 +405,12 @@ class MiqtVirtualQAbstractItemView final : public QAbstractItemView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QAbstractItemView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -777,13 +777,13 @@ class MiqtVirtualQAbstractItemView final : public QAbstractItemView { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractItemView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QAbstractItemView_virtualbase_selectedIndexes(const void* self); @@ -2379,13 +2379,13 @@ 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) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QAbstractItemView::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QAbstractItemView::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QAbstractItemView_override_virtual_rowsInserted(void* self, intptr_t slot) { @@ -2657,12 +2657,12 @@ bool QAbstractItemView_override_virtual_selectedIndexes(void* self, intptr_t slo struct miqt_array /* of QModelIndex* */ QAbstractItemView_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QAbstractItemView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qabstractproxymodel.cpp b/qt/gen_qabstractproxymodel.cpp index b9b0e43d3c..5540cbf423 100644 --- a/qt/gen_qabstractproxymodel.cpp +++ b/qt/gen_qabstractproxymodel.cpp @@ -499,12 +499,12 @@ class MiqtVirtualQAbstractProxyModel final : public QAbstractProxyModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -569,14 +569,14 @@ class MiqtVirtualQAbstractProxyModel final : public QAbstractProxyModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_virtualbase_mimeTypes(const void* self); @@ -825,13 +825,13 @@ class MiqtVirtualQAbstractProxyModel final : public QAbstractProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QAbstractProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -1161,13 +1161,13 @@ QModelIndex* QAbstractProxyModel_sibling(const QAbstractProxyModel* self, int ro } QMimeData* QAbstractProxyModel_mimeData(const QAbstractProxyModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return self->mimeData(indexes_QList); + return self->mimeData(indexes_QModelIndexList); } bool QAbstractProxyModel_canDropMimeData(const QAbstractProxyModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { @@ -1181,8 +1181,8 @@ bool QAbstractProxyModel_dropMimeData(QAbstractProxyModel* self, QMimeData* data struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_mimeTypes(const QAbstractProxyModel* self) { QStringList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1193,7 +1193,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_mimeTypes(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1570,13 +1570,13 @@ bool QAbstractProxyModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QAbstractProxyModel::mimeData(indexes_QList); + return static_cast(self)->QAbstractProxyModel::mimeData(indexes_QModelIndexList); } bool QAbstractProxyModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -1620,8 +1620,8 @@ bool QAbstractProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QAbstractProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1632,7 +1632,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_virtualbase_m _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1804,12 +1804,12 @@ 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) { QModelIndexList _ret = static_cast(self)->QAbstractProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1975,13 +1975,13 @@ void QAbstractProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QAbstractProxyModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2168,19 +2168,19 @@ void QAbstractProxyModel_protectedbase_changePersistentIndexList(bool* _dynamic_ } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QAbstractProxyModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2193,12 +2193,12 @@ struct miqt_array /* of QModelIndex* */ QAbstractProxyModel_protectedbase_persi *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qabstractscrollarea.cpp b/qt/gen_qabstractscrollarea.cpp index 994b1d89b2..cde5eb390e 100644 --- a/qt/gen_qabstractscrollarea.cpp +++ b/qt/gen_qabstractscrollarea.cpp @@ -1076,12 +1076,12 @@ void QAbstractScrollArea_addScrollBarWidget(QAbstractScrollArea* self, QWidget* struct miqt_array /* of QWidget* */ QAbstractScrollArea_scrollBarWidgets(QAbstractScrollArea* self, int alignment) { QWidgetList _ret = self->scrollBarWidgets(static_cast(alignment)); // Convert QList<> from C++ memory to manually-managed C memory - QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qabstracttransition.cpp b/qt/gen_qabstracttransition.cpp index 8bd1947d66..5d14f51d10 100644 --- a/qt/gen_qabstracttransition.cpp +++ b/qt/gen_qabstracttransition.cpp @@ -258,12 +258,12 @@ void QAbstractTransition_setTargetState(QAbstractTransition* self, QAbstractStat struct miqt_array /* of QAbstractState* */ QAbstractTransition_targetStates(const QAbstractTransition* self) { QList _ret = self->targetStates(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractState** _arr = static_cast(malloc(sizeof(QAbstractState*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractState** _arr = static_cast(malloc(sizeof(QAbstractState*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -302,12 +302,12 @@ void QAbstractTransition_removeAnimation(QAbstractTransition* self, QAbstractAni struct miqt_array /* of QAbstractAnimation* */ QAbstractTransition_animations(const QAbstractTransition* self) { QList _ret = self->animations(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAnimation** _arr = static_cast(malloc(sizeof(QAbstractAnimation*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAnimation** _arr = static_cast(malloc(sizeof(QAbstractAnimation*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qaccessible.cpp b/qt/gen_qaccessible.cpp index 7901cf3fd3..824b6c24ea 100644 --- a/qt/gen_qaccessible.cpp +++ b/qt/gen_qaccessible.cpp @@ -135,8 +135,8 @@ 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) { QVector> _ret = self->relations(static_cast(match)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair> _vv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory QAccessibleInterface** _vv_first_arr = static_cast(malloc(sizeof(QAccessibleInterface*))); @@ -151,7 +151,7 @@ struct miqt_array /* of struct miqt_map tuple of QAccessibleInterface* and int _arr[i] = _vv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -417,12 +417,12 @@ bool QAccessibleTableCellInterface_isSelected(const QAccessibleTableCellInterfac struct miqt_array /* of QAccessibleInterface* */ QAccessibleTableCellInterface_columnHeaderCells(const QAccessibleTableCellInterface* self) { QList _ret = self->columnHeaderCells(); // Convert QList<> from C++ memory to manually-managed C memory - QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -430,12 +430,12 @@ struct miqt_array /* of QAccessibleInterface* */ QAccessibleTableCellInterface_ struct miqt_array /* of QAccessibleInterface* */ QAccessibleTableCellInterface_rowHeaderCells(const QAccessibleTableCellInterface* self) { QList _ret = self->rowHeaderCells(); // Convert QList<> from C++ memory to manually-managed C memory - QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -487,12 +487,12 @@ int QAccessibleTableInterface_selectedCellCount(const QAccessibleTableInterface* struct miqt_array /* of QAccessibleInterface* */ QAccessibleTableInterface_selectedCells(const QAccessibleTableInterface* self) { QList _ret = self->selectedCells(); // Convert QList<> from C++ memory to manually-managed C memory - QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -538,12 +538,12 @@ int QAccessibleTableInterface_rowCount(const QAccessibleTableInterface* self) { struct miqt_array /* of int */ QAccessibleTableInterface_selectedColumns(const QAccessibleTableInterface* self) { QList _ret = self->selectedColumns(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -551,12 +551,12 @@ struct miqt_array /* of int */ QAccessibleTableInterface_selectedColumns(const struct miqt_array /* of int */ QAccessibleTableInterface_selectedRows(const QAccessibleTableInterface* self) { QList _ret = self->selectedRows(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -618,8 +618,8 @@ struct miqt_string QAccessibleActionInterface_trUtf8(const char* sourceText) { struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_actionNames(const QAccessibleActionInterface* self) { QStringList _ret = self->actionNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -630,7 +630,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_action _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -668,8 +668,8 @@ struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_keyBin 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(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -680,7 +680,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_keyBin _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qaccessiblewidget.cpp b/qt/gen_qaccessiblewidget.cpp index f79654320d..3c319ec427 100644 --- a/qt/gen_qaccessiblewidget.cpp +++ b/qt/gen_qaccessiblewidget.cpp @@ -62,8 +62,8 @@ int QAccessibleWidget_indexOfChild(const QAccessibleWidget* self, QAccessibleInt struct miqt_array /* of struct miqt_map tuple of QAccessibleInterface* and int */ QAccessibleWidget_relations(const QAccessibleWidget* self, int match) { QVector> _ret = self->relations(static_cast(match)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair> _vv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory QAccessibleInterface** _vv_first_arr = static_cast(malloc(sizeof(QAccessibleInterface*))); @@ -78,7 +78,7 @@ struct miqt_array /* of struct miqt_map tuple of QAccessibleInterface* and int _arr[i] = _vv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -134,8 +134,8 @@ void* QAccessibleWidget_interfaceCast(QAccessibleWidget* self, int 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(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -146,7 +146,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleWidget_actionNames(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -160,8 +160,8 @@ struct miqt_array /* of struct miqt_string */ QAccessibleWidget_keyBindingsForA 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(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -172,7 +172,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleWidget_keyBindingsForA _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qaction.cpp b/qt/gen_qaction.cpp index 304002e389..d8b943b784 100644 --- a/qt/gen_qaction.cpp +++ b/qt/gen_qaction.cpp @@ -389,12 +389,12 @@ void QAction_setShortcutsWithShortcuts(QAction* self, int shortcuts) { struct miqt_array /* of QKeySequence* */ QAction_shortcuts(const QAction* self) { QList _ret = self->shortcuts(); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -492,12 +492,12 @@ QWidget* QAction_parentWidget(const QAction* self) { struct miqt_array /* of QWidget* */ QAction_associatedWidgets(const QAction* self) { QList _ret = self->associatedWidgets(); // Convert QList<> from C++ memory to manually-managed C memory - QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -505,12 +505,12 @@ struct miqt_array /* of QWidget* */ QAction_associatedWidgets(const QAction* se struct miqt_array /* of QGraphicsWidget* */ QAction_associatedGraphicsWidgets(const QAction* self) { QList _ret = self->associatedGraphicsWidgets(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsWidget** _arr = static_cast(malloc(sizeof(QGraphicsWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsWidget** _arr = static_cast(malloc(sizeof(QGraphicsWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qactiongroup.cpp b/qt/gen_qactiongroup.cpp index 5a40c61814..872599abdf 100644 --- a/qt/gen_qactiongroup.cpp +++ b/qt/gen_qactiongroup.cpp @@ -226,12 +226,12 @@ void QActionGroup_removeAction(QActionGroup* self, QAction* a) { struct miqt_array /* of QAction* */ QActionGroup_actions(const QActionGroup* self) { QList _ret = self->actions(); // Convert QList<> from C++ memory to manually-managed C memory - QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qapplication.cpp b/qt/gen_qapplication.cpp index 42e5ef2eb7..7bb3acf5e3 100644 --- a/qt/gen_qapplication.cpp +++ b/qt/gen_qapplication.cpp @@ -300,12 +300,12 @@ QIcon* QApplication_windowIcon() { 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(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -313,12 +313,12 @@ struct miqt_array /* of QWidget* */ QApplication_allWidgets() { 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(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qbrush.cpp b/qt/gen_qbrush.cpp index 5c9bd12f07..6206ecf7cc 100644 --- a/qt/gen_qbrush.cpp +++ b/qt/gen_qbrush.cpp @@ -209,8 +209,8 @@ void QGradient_setColorAt(QGradient* self, double pos, QColor* color) { } void QGradient_setStops(QGradient* self, struct miqt_array /* of struct miqt_map tuple of double and QColor* */ stops) { - QGradientStops stops_QList; - stops_QList.reserve(stops.len); + QGradientStops stops_QGradientStops; + stops_QGradientStops.reserve(stops.len); struct miqt_map /* tuple of double and QColor* */ * stops_arr = static_cast(stops.data); for(size_t i = 0; i < stops.len; ++i) { QPair stops_arr_i_QPair; @@ -218,16 +218,16 @@ void QGradient_setStops(QGradient* self, struct miqt_array /* of struct miqt_map QColor** stops_arr_i_second_arr = static_cast(stops_arr[i].values); stops_arr_i_QPair.first = static_cast(stops_arr_i_first_arr[0]); stops_arr_i_QPair.second = *(stops_arr_i_second_arr[0]); - stops_QList.push_back(stops_arr_i_QPair); + stops_QGradientStops.push_back(stops_arr_i_QPair); } - self->setStops(stops_QList); + self->setStops(stops_QGradientStops); } struct miqt_array /* of struct miqt_map tuple of double and QColor* */ QGradient_stops(const QGradient* self) { QGradientStops _ret = self->stops(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QColor* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QColor* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QColor* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QColor* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _vv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _vv_first_arr = static_cast(malloc(sizeof(double))); @@ -241,7 +241,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QColor* */ QGrad _arr[i] = _vv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qbuttongroup.cpp b/qt/gen_qbuttongroup.cpp index fb8a251b74..6716814cbd 100644 --- a/qt/gen_qbuttongroup.cpp +++ b/qt/gen_qbuttongroup.cpp @@ -238,12 +238,12 @@ void QButtonGroup_removeButton(QButtonGroup* self, QAbstractButton* param1) { struct miqt_array /* of QAbstractButton* */ QButtonGroup_buttons(const QButtonGroup* self) { QList _ret = self->buttons(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcalendar.cpp b/qt/gen_qcalendar.cpp index e8e90764b5..2c7423678c 100644 --- a/qt/gen_qcalendar.cpp +++ b/qt/gen_qcalendar.cpp @@ -159,8 +159,8 @@ struct miqt_string QCalendar_standaloneWeekDayName(const QCalendar* self, QLocal struct miqt_array /* of struct miqt_string */ QCalendar_availableCalendars() { QStringList _ret = QCalendar::availableCalendars(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -171,7 +171,7 @@ struct miqt_array /* of struct miqt_string */ QCalendar_availableCalendars() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcolor.cpp b/qt/gen_qcolor.cpp index a2d61ab157..9c0a87c159 100644 --- a/qt/gen_qcolor.cpp +++ b/qt/gen_qcolor.cpp @@ -107,8 +107,8 @@ void QColor_setNamedColor(QColor* self, struct miqt_string name) { struct miqt_array /* of struct miqt_string */ QColor_colorNames() { QStringList _ret = QColor::colorNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -119,7 +119,7 @@ struct miqt_array /* of struct miqt_string */ QColor_colorNames() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcolormap.cpp b/qt/gen_qcolormap.cpp index 37ce6bf21a..85d1b028cc 100644 --- a/qt/gen_qcolormap.cpp +++ b/qt/gen_qcolormap.cpp @@ -57,12 +57,12 @@ QColor* QColormap_colorAt(const QColormap* self, unsigned int pixel) { struct miqt_array /* of QColor* */ QColormap_colormap(const QColormap* self) { const QVector _ret = self->colormap(); // Convert QList<> from C++ memory to manually-managed C memory - QColor** _arr = static_cast(malloc(sizeof(QColor*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QColor** _arr = static_cast(malloc(sizeof(QColor*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QColor(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcolumnview.cpp b/qt/gen_qcolumnview.cpp index 5e7a7ab91d..19fca75e1b 100644 --- a/qt/gen_qcolumnview.cpp +++ b/qt/gen_qcolumnview.cpp @@ -624,12 +624,12 @@ class MiqtVirtualQColumnView final : public QColumnView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QColumnView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -860,13 +860,13 @@ class MiqtVirtualQColumnView final : public QColumnView { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QColumnView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QColumnView_virtualbase_selectedIndexes(const void* self); @@ -1884,12 +1884,12 @@ void QColumnView_setColumnWidths(QColumnView* self, struct miqt_array /* of int struct miqt_array /* of int */ QColumnView_columnWidths(const QColumnView* self) { QList _ret = self->columnWidths(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2300,13 +2300,13 @@ bool QColumnView_override_virtual_dataChanged(void* self, intptr_t slot) { } void QColumnView_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QColumnView::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QColumnView::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QColumnView_override_virtual_rowsAboutToBeRemoved(void* self, intptr_t slot) { @@ -2490,12 +2490,12 @@ bool QColumnView_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QColumnView_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QColumnView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcombobox.cpp b/qt/gen_qcombobox.cpp index 4d6a25fb3b..6929569750 100644 --- a/qt/gen_qcombobox.cpp +++ b/qt/gen_qcombobox.cpp @@ -1227,14 +1227,14 @@ void QComboBox_addItem2(QComboBox* self, QIcon* icon, struct miqt_string text) { } void QComboBox_addItems(QComboBox* self, struct miqt_array /* of struct miqt_string */ texts) { - QStringList texts_QList; - texts_QList.reserve(texts.len); + QStringList texts_QStringList; + texts_QStringList.reserve(texts.len); struct miqt_string* texts_arr = static_cast(texts.data); for(size_t i = 0; i < texts.len; ++i) { QString texts_arr_i_QString = QString::fromUtf8(texts_arr[i].data, texts_arr[i].len); - texts_QList.push_back(texts_arr_i_QString); + texts_QStringList.push_back(texts_arr_i_QString); } - self->addItems(texts_QList); + self->addItems(texts_QStringList); } void QComboBox_insertItem(QComboBox* self, int index, struct miqt_string text) { @@ -1248,14 +1248,14 @@ void QComboBox_insertItem2(QComboBox* self, int index, QIcon* icon, struct miqt_ } void QComboBox_insertItems(QComboBox* self, int index, struct miqt_array /* of struct miqt_string */ texts) { - QStringList texts_QList; - texts_QList.reserve(texts.len); + QStringList texts_QStringList; + texts_QStringList.reserve(texts.len); struct miqt_string* texts_arr = static_cast(texts.data); for(size_t i = 0; i < texts.len; ++i) { QString texts_arr_i_QString = QString::fromUtf8(texts_arr[i].data, texts_arr[i].len); - texts_QList.push_back(texts_arr_i_QString); + texts_QStringList.push_back(texts_arr_i_QString); } - self->insertItems(static_cast(index), texts_QList); + self->insertItems(static_cast(index), texts_QStringList); } void QComboBox_insertSeparator(QComboBox* self, int index) { diff --git a/qt/gen_qcommandlineoption.cpp b/qt/gen_qcommandlineoption.cpp index bf55d34359..d6d64b0eea 100644 --- a/qt/gen_qcommandlineoption.cpp +++ b/qt/gen_qcommandlineoption.cpp @@ -20,14 +20,14 @@ QCommandLineOption* QCommandLineOption_new(struct miqt_string name) { } QCommandLineOption* QCommandLineOption_new2(struct miqt_array /* of struct miqt_string */ names) { - QStringList names_QList; - names_QList.reserve(names.len); + QStringList names_QStringList; + names_QStringList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { QString names_arr_i_QString = QString::fromUtf8(names_arr[i].data, names_arr[i].len); - names_QList.push_back(names_arr_i_QString); + names_QStringList.push_back(names_arr_i_QString); } - return new (std::nothrow) QCommandLineOption(names_QList); + return new (std::nothrow) QCommandLineOption(names_QStringList); } QCommandLineOption* QCommandLineOption_new3(struct miqt_string name, struct miqt_string description) { @@ -37,15 +37,15 @@ QCommandLineOption* QCommandLineOption_new3(struct miqt_string name, struct miqt } QCommandLineOption* QCommandLineOption_new4(struct miqt_array /* of struct miqt_string */ names, struct miqt_string description) { - QStringList names_QList; - names_QList.reserve(names.len); + QStringList names_QStringList; + names_QStringList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { QString names_arr_i_QString = QString::fromUtf8(names_arr[i].data, names_arr[i].len); - names_QList.push_back(names_arr_i_QString); + names_QStringList.push_back(names_arr_i_QString); } QString description_QString = QString::fromUtf8(description.data, description.len); - return new (std::nothrow) QCommandLineOption(names_QList, description_QString); + return new (std::nothrow) QCommandLineOption(names_QStringList, description_QString); } QCommandLineOption* QCommandLineOption_new5(QCommandLineOption* other) { @@ -68,30 +68,30 @@ QCommandLineOption* QCommandLineOption_new7(struct miqt_string name, struct miqt } QCommandLineOption* QCommandLineOption_new8(struct miqt_array /* of struct miqt_string */ names, struct miqt_string description, struct miqt_string valueName) { - QStringList names_QList; - names_QList.reserve(names.len); + QStringList names_QStringList; + names_QStringList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { QString names_arr_i_QString = QString::fromUtf8(names_arr[i].data, names_arr[i].len); - names_QList.push_back(names_arr_i_QString); + names_QStringList.push_back(names_arr_i_QString); } QString description_QString = QString::fromUtf8(description.data, description.len); QString valueName_QString = QString::fromUtf8(valueName.data, valueName.len); - return new (std::nothrow) QCommandLineOption(names_QList, description_QString, valueName_QString); + return new (std::nothrow) QCommandLineOption(names_QStringList, description_QString, valueName_QString); } QCommandLineOption* QCommandLineOption_new9(struct miqt_array /* of struct miqt_string */ names, struct miqt_string description, struct miqt_string valueName, struct miqt_string defaultValue) { - QStringList names_QList; - names_QList.reserve(names.len); + QStringList names_QStringList; + names_QStringList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { QString names_arr_i_QString = QString::fromUtf8(names_arr[i].data, names_arr[i].len); - names_QList.push_back(names_arr_i_QString); + names_QStringList.push_back(names_arr_i_QString); } QString description_QString = QString::fromUtf8(description.data, description.len); QString valueName_QString = QString::fromUtf8(valueName.data, valueName.len); QString defaultValue_QString = QString::fromUtf8(defaultValue.data, defaultValue.len); - return new (std::nothrow) QCommandLineOption(names_QList, description_QString, valueName_QString, defaultValue_QString); + return new (std::nothrow) QCommandLineOption(names_QStringList, description_QString, valueName_QString, defaultValue_QString); } void QCommandLineOption_operatorAssign(QCommandLineOption* self, QCommandLineOption* other) { @@ -105,8 +105,8 @@ void QCommandLineOption_swap(QCommandLineOption* self, QCommandLineOption* other struct miqt_array /* of struct miqt_string */ QCommandLineOption_names(const QCommandLineOption* self) { QStringList _ret = self->names(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -117,7 +117,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineOption_names(const QC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -160,21 +160,21 @@ void QCommandLineOption_setDefaultValue(QCommandLineOption* self, struct miqt_st } void QCommandLineOption_setDefaultValues(QCommandLineOption* self, struct miqt_array /* of struct miqt_string */ defaultValues) { - QStringList defaultValues_QList; - defaultValues_QList.reserve(defaultValues.len); + QStringList defaultValues_QStringList; + defaultValues_QStringList.reserve(defaultValues.len); struct miqt_string* defaultValues_arr = static_cast(defaultValues.data); for(size_t i = 0; i < defaultValues.len; ++i) { QString defaultValues_arr_i_QString = QString::fromUtf8(defaultValues_arr[i].data, defaultValues_arr[i].len); - defaultValues_QList.push_back(defaultValues_arr_i_QString); + defaultValues_QStringList.push_back(defaultValues_arr_i_QString); } - self->setDefaultValues(defaultValues_QList); + self->setDefaultValues(defaultValues_QStringList); } struct miqt_array /* of struct miqt_string */ QCommandLineOption_defaultValues(const QCommandLineOption* self) { QStringList _ret = self->defaultValues(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -185,7 +185,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineOption_defaultValues( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcommandlineparser.cpp b/qt/gen_qcommandlineparser.cpp index 984891c939..6f8efaf2e4 100644 --- a/qt/gen_qcommandlineparser.cpp +++ b/qt/gen_qcommandlineparser.cpp @@ -99,14 +99,14 @@ void QCommandLineParser_clearPositionalArguments(QCommandLineParser* self) { } void QCommandLineParser_process(QCommandLineParser* self, struct miqt_array /* of struct miqt_string */ arguments) { - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } - self->process(arguments_QList); + self->process(arguments_QStringList); } void QCommandLineParser_processWithApp(QCommandLineParser* self, QCoreApplication* app) { @@ -114,14 +114,14 @@ void QCommandLineParser_processWithApp(QCommandLineParser* self, QCoreApplicatio } bool QCommandLineParser_parse(QCommandLineParser* self, struct miqt_array /* of struct miqt_string */ arguments) { - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } - return self->parse(arguments_QList); + return self->parse(arguments_QStringList); } struct miqt_string QCommandLineParser_errorText(const QCommandLineParser* self) { @@ -156,8 +156,8 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_values(const Q QString name_QString = QString::fromUtf8(name.data, name.len); QStringList _ret = self->values(name_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -168,7 +168,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_values(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -191,8 +191,8 @@ struct miqt_string QCommandLineParser_valueWithOption(const QCommandLineParser* struct miqt_array /* of struct miqt_string */ QCommandLineParser_valuesWithOption(const QCommandLineParser* self, QCommandLineOption* option) { QStringList _ret = self->values(*option); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -203,7 +203,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_valuesWithOpti _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -211,8 +211,8 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_valuesWithOpti struct miqt_array /* of struct miqt_string */ QCommandLineParser_positionalArguments(const QCommandLineParser* self) { QStringList _ret = self->positionalArguments(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -223,7 +223,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_positionalArgu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -231,8 +231,8 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_positionalArgu struct miqt_array /* of struct miqt_string */ QCommandLineParser_optionNames(const QCommandLineParser* self) { QStringList _ret = self->optionNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -243,7 +243,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_optionNames(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -251,8 +251,8 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_optionNames(co struct miqt_array /* of struct miqt_string */ QCommandLineParser_unknownOptionNames(const QCommandLineParser* self) { QStringList _ret = self->unknownOptionNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -263,7 +263,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_unknownOptionN _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcompleter.cpp b/qt/gen_qcompleter.cpp index 78379fa627..f33a26e548 100644 --- a/qt/gen_qcompleter.cpp +++ b/qt/gen_qcompleter.cpp @@ -87,14 +87,14 @@ class MiqtVirtualQCompleter final : public QCompleter { memcpy(path_ms.data, path_b.data(), path_ms.len); struct miqt_string sigval1 = path_ms; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QCompleter_splitPath(this, handle__splitPath, sigval1); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QCompleter_virtualbase_splitPath(const void* self, struct miqt_string path); @@ -237,14 +237,14 @@ QCompleter* QCompleter_new2(QAbstractItemModel* model) { } QCompleter* QCompleter_new3(struct miqt_array /* of struct miqt_string */ completions) { - QStringList completions_QList; - completions_QList.reserve(completions.len); + QStringList completions_QStringList; + completions_QStringList.reserve(completions.len); struct miqt_string* completions_arr = static_cast(completions.data); for(size_t i = 0; i < completions.len; ++i) { QString completions_arr_i_QString = QString::fromUtf8(completions_arr[i].data, completions_arr[i].len); - completions_QList.push_back(completions_arr_i_QString); + completions_QStringList.push_back(completions_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQCompleter(completions_QList); + return new (std::nothrow) MiqtVirtualQCompleter(completions_QStringList); } QCompleter* QCompleter_new4(QObject* parent) { @@ -256,14 +256,14 @@ QCompleter* QCompleter_new5(QAbstractItemModel* model, QObject* parent) { } QCompleter* QCompleter_new6(struct miqt_array /* of struct miqt_string */ completions, QObject* parent) { - QStringList completions_QList; - completions_QList.reserve(completions.len); + QStringList completions_QStringList; + completions_QStringList.reserve(completions.len); struct miqt_string* completions_arr = static_cast(completions.data); for(size_t i = 0; i < completions.len; ++i) { QString completions_arr_i_QString = QString::fromUtf8(completions_arr[i].data, completions_arr[i].len); - completions_QList.push_back(completions_arr_i_QString); + completions_QStringList.push_back(completions_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQCompleter(completions_QList, parent); + return new (std::nothrow) MiqtVirtualQCompleter(completions_QStringList, parent); } void QCompleter_virtbase(QCompleter* src, QObject** outptr_QObject) { @@ -458,8 +458,8 @@ struct miqt_array /* of struct miqt_string */ QCompleter_splitPath(const QCompl QString path_QString = QString::fromUtf8(path.data, path.len); QStringList _ret = self->splitPath(path_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -470,7 +470,7 @@ struct miqt_array /* of struct miqt_string */ QCompleter_splitPath(const QCompl _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -622,8 +622,8 @@ struct miqt_array /* of struct miqt_string */ QCompleter_virtualbase_splitPath( QString path_QString = QString::fromUtf8(path.data, path.len); QStringList _ret = static_cast(self)->QCompleter::splitPath(path_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -634,7 +634,7 @@ struct miqt_array /* of struct miqt_string */ QCompleter_virtualbase_splitPath( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qconcatenatetablesproxymodel.cpp b/qt/gen_qconcatenatetablesproxymodel.cpp index 77dcf21865..140d15eaf8 100644 --- a/qt/gen_qconcatenatetablesproxymodel.cpp +++ b/qt/gen_qconcatenatetablesproxymodel.cpp @@ -297,14 +297,14 @@ class MiqtVirtualQConcatenateTablesProxyModel final : public QConcatenateTablesP } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QConcatenateTablesProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_virtualbase_mimeTypes(const void* self); @@ -320,12 +320,12 @@ class MiqtVirtualQConcatenateTablesProxyModel final : public QConcatenateTablesP const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QConcatenateTablesProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -710,13 +710,13 @@ class MiqtVirtualQConcatenateTablesProxyModel final : public QConcatenateTablesP Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QConcatenateTablesProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QConcatenateTablesProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -970,12 +970,12 @@ struct miqt_string QConcatenateTablesProxyModel_trUtf8(const char* s) { struct miqt_array /* of QAbstractItemModel* */ QConcatenateTablesProxyModel_sourceModels(const QConcatenateTablesProxyModel* self) { QList _ret = self->sourceModels(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractItemModel** _arr = static_cast(malloc(sizeof(QAbstractItemModel*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractItemModel** _arr = static_cast(malloc(sizeof(QAbstractItemModel*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1060,8 +1060,8 @@ int QConcatenateTablesProxyModel_columnCount(const QConcatenateTablesProxyModel* struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_mimeTypes(const QConcatenateTablesProxyModel* self) { QStringList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1072,19 +1072,19 @@ struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_mime _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QConcatenateTablesProxyModel_mimeData(const QConcatenateTablesProxyModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return self->mimeData(indexes_QList); + return self->mimeData(indexes_QModelIndexList); } bool QConcatenateTablesProxyModel_canDropMimeData(const QConcatenateTablesProxyModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { @@ -1317,8 +1317,8 @@ bool QConcatenateTablesProxyModel_override_virtual_mimeTypes(void* self, intptr_ struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QConcatenateTablesProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1329,7 +1329,7 @@ struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_virt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1345,13 +1345,13 @@ bool QConcatenateTablesProxyModel_override_virtual_mimeData(void* self, intptr_t } QMimeData* QConcatenateTablesProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QConcatenateTablesProxyModel::mimeData(indexes_QList); + return static_cast(self)->QConcatenateTablesProxyModel::mimeData(indexes_QModelIndexList); } bool QConcatenateTablesProxyModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -1621,12 +1621,12 @@ bool QConcatenateTablesProxyModel_override_virtual_match(void* self, intptr_t sl struct miqt_array /* of QModelIndex* */ QConcatenateTablesProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QConcatenateTablesProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1820,13 +1820,13 @@ void QConcatenateTablesProxyModel_protectedbase_encodeData(bool* _dynamic_cast_o } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QConcatenateTablesProxyModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2013,19 +2013,19 @@ void QConcatenateTablesProxyModel_protectedbase_changePersistentIndexList(bool* } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QConcatenateTablesProxyModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2038,12 +2038,12 @@ struct miqt_array /* of QModelIndex* */ QConcatenateTablesProxyModel_protectedb *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qcoreapplication.cpp b/qt/gen_qcoreapplication.cpp index fd7259f6d9..3c44be0c25 100644 --- a/qt/gen_qcoreapplication.cpp +++ b/qt/gen_qcoreapplication.cpp @@ -235,8 +235,8 @@ struct miqt_string QCoreApplication_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QCoreApplication_arguments() { QStringList _ret = QCoreApplication::arguments(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -247,7 +247,7 @@ struct miqt_array /* of struct miqt_string */ QCoreApplication_arguments() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -420,21 +420,21 @@ long long QCoreApplication_applicationPid() { } void QCoreApplication_setLibraryPaths(struct miqt_array /* of struct miqt_string */ libraryPaths) { - QStringList libraryPaths_QList; - libraryPaths_QList.reserve(libraryPaths.len); + QStringList libraryPaths_QStringList; + libraryPaths_QStringList.reserve(libraryPaths.len); struct miqt_string* libraryPaths_arr = static_cast(libraryPaths.data); for(size_t i = 0; i < libraryPaths.len; ++i) { QString libraryPaths_arr_i_QString = QString::fromUtf8(libraryPaths_arr[i].data, libraryPaths_arr[i].len); - libraryPaths_QList.push_back(libraryPaths_arr_i_QString); + libraryPaths_QStringList.push_back(libraryPaths_arr_i_QString); } - QCoreApplication::setLibraryPaths(libraryPaths_QList); + QCoreApplication::setLibraryPaths(libraryPaths_QStringList); } struct miqt_array /* of struct miqt_string */ QCoreApplication_libraryPaths() { QStringList _ret = QCoreApplication::libraryPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -445,7 +445,7 @@ struct miqt_array /* of struct miqt_string */ QCoreApplication_libraryPaths() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qdialogbuttonbox.cpp b/qt/gen_qdialogbuttonbox.cpp index d3adc8562e..b961662062 100644 --- a/qt/gen_qdialogbuttonbox.cpp +++ b/qt/gen_qdialogbuttonbox.cpp @@ -1017,12 +1017,12 @@ void QDialogButtonBox_clear(QDialogButtonBox* self) { struct miqt_array /* of QAbstractButton* */ QDialogButtonBox_buttons(const QDialogButtonBox* self) { QList _ret = self->buttons(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qdir.cpp b/qt/gen_qdir.cpp index 2056ad654f..b5e5832985 100644 --- a/qt/gen_qdir.cpp +++ b/qt/gen_qdir.cpp @@ -105,14 +105,14 @@ void QDir_addResourceSearchPath(struct miqt_string path) { void QDir_setSearchPaths(struct miqt_string prefix, struct miqt_array /* of struct miqt_string */ searchPaths) { QString prefix_QString = QString::fromUtf8(prefix.data, prefix.len); - QStringList searchPaths_QList; - searchPaths_QList.reserve(searchPaths.len); + QStringList searchPaths_QStringList; + searchPaths_QStringList.reserve(searchPaths.len); struct miqt_string* searchPaths_arr = static_cast(searchPaths.data); for(size_t i = 0; i < searchPaths.len; ++i) { QString searchPaths_arr_i_QString = QString::fromUtf8(searchPaths_arr[i].data, searchPaths_arr[i].len); - searchPaths_QList.push_back(searchPaths_arr_i_QString); + searchPaths_QStringList.push_back(searchPaths_arr_i_QString); } - QDir::setSearchPaths(prefix_QString, searchPaths_QList); + QDir::setSearchPaths(prefix_QString, searchPaths_QStringList); } void QDir_addSearchPath(struct miqt_string prefix, struct miqt_string path) { @@ -125,8 +125,8 @@ struct miqt_array /* of struct miqt_string */ QDir_searchPaths(struct miqt_stri QString prefix_QString = QString::fromUtf8(prefix.data, prefix.len); QStringList _ret = QDir::searchPaths(prefix_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -137,7 +137,7 @@ struct miqt_array /* of struct miqt_string */ QDir_searchPaths(struct miqt_stri _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -225,8 +225,8 @@ bool QDir_cdUp(QDir* self) { struct miqt_array /* of struct miqt_string */ QDir_nameFilters(const QDir* self) { QStringList _ret = self->nameFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -237,20 +237,20 @@ struct miqt_array /* of struct miqt_string */ QDir_nameFilters(const QDir* self _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QDir_setNameFilters(QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - self->setNameFilters(nameFilters_QList); + self->setNameFilters(nameFilters_QStringList); } int QDir_filter(const QDir* self) { @@ -295,8 +295,8 @@ struct miqt_array /* of struct miqt_string */ QDir_nameFiltersFromString(struct QString nameFilter_QString = QString::fromUtf8(nameFilter.data, nameFilter.len); QStringList _ret = QDir::nameFiltersFromString(nameFilter_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -307,7 +307,7 @@ struct miqt_array /* of struct miqt_string */ QDir_nameFiltersFromString(struct _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -315,8 +315,8 @@ struct miqt_array /* of struct miqt_string */ QDir_nameFiltersFromString(struct struct miqt_array /* of struct miqt_string */ QDir_entryList(const QDir* self) { QStringList _ret = self->entryList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -327,23 +327,23 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList(const QDir* self) _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryListWithNameFilters(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - QStringList _ret = self->entryList(nameFilters_QList); + QStringList _ret = self->entryList(nameFilters_QStringList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -354,7 +354,7 @@ struct miqt_array /* of struct miqt_string */ QDir_entryListWithNameFilters(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -362,32 +362,32 @@ struct miqt_array /* of struct miqt_string */ QDir_entryListWithNameFilters(con struct miqt_array /* of QFileInfo* */ QDir_entryInfoList(const QDir* self) { QFileInfoList _ret = self->entryInfoList(); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoListWithNameFilters(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - QFileInfoList _ret = self->entryInfoList(nameFilters_QList); + QFileInfoList _ret = self->entryInfoList(nameFilters_QStringList); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -477,12 +477,12 @@ bool QDir_existsWithName(const QDir* self, struct miqt_string name) { struct miqt_array /* of QFileInfo* */ QDir_drives() { QFileInfoList _ret = QDir::drives(); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -561,15 +561,15 @@ struct miqt_string QDir_tempPath() { } bool QDir_match(struct miqt_array /* of struct miqt_string */ filters, struct miqt_string fileName) { - QStringList filters_QList; - filters_QList.reserve(filters.len); + QStringList filters_QStringList; + filters_QStringList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { QString filters_arr_i_QString = QString::fromUtf8(filters_arr[i].data, filters_arr[i].len); - filters_QList.push_back(filters_arr_i_QString); + filters_QStringList.push_back(filters_arr_i_QString); } QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - return QDir::match(filters_QList, fileName_QString); + return QDir::match(filters_QStringList, fileName_QString); } bool QDir_match2(struct miqt_string filter, struct miqt_string fileName) { @@ -601,8 +601,8 @@ bool QDir_isEmptyWithFilters(const QDir* self, int filters) { struct miqt_array /* of struct miqt_string */ QDir_entryListWithFilters(const QDir* self, int filters) { QStringList _ret = self->entryList(static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -613,7 +613,7 @@ struct miqt_array /* of struct miqt_string */ QDir_entryListWithFilters(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -621,8 +621,8 @@ struct miqt_array /* of struct miqt_string */ QDir_entryListWithFilters(const Q struct miqt_array /* of struct miqt_string */ QDir_entryList2(const QDir* self, int filters, int sort) { QStringList _ret = self->entryList(static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -633,23 +633,23 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList2(const QDir* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryList3(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - QStringList _ret = self->entryList(nameFilters_QList, static_cast(filters)); + QStringList _ret = self->entryList(nameFilters_QStringList, static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -660,23 +660,23 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList3(const QDir* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryList4(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int sort) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - QStringList _ret = self->entryList(nameFilters_QList, static_cast(filters), static_cast(sort)); + QStringList _ret = self->entryList(nameFilters_QStringList, static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -687,7 +687,7 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList4(const QDir* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -695,12 +695,12 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList4(const QDir* self, struct miqt_array /* of QFileInfo* */ QDir_entryInfoListWithFilters(const QDir* self, int filters) { QFileInfoList _ret = self->entryInfoList(static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -708,52 +708,52 @@ struct miqt_array /* of QFileInfo* */ QDir_entryInfoListWithFilters(const QDir* struct miqt_array /* of QFileInfo* */ QDir_entryInfoList2(const QDir* self, int filters, int sort) { QFileInfoList _ret = self->entryInfoList(static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoList3(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - QFileInfoList _ret = self->entryInfoList(nameFilters_QList, static_cast(filters)); + QFileInfoList _ret = self->entryInfoList(nameFilters_QStringList, static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoList4(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int sort) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - QFileInfoList _ret = self->entryInfoList(nameFilters_QList, static_cast(filters), static_cast(sort)); + QFileInfoList _ret = self->entryInfoList(nameFilters_QStringList, static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qdiriterator.cpp b/qt/gen_qdiriterator.cpp index 49f7db8434..cb189dc37f 100644 --- a/qt/gen_qdiriterator.cpp +++ b/qt/gen_qdiriterator.cpp @@ -32,14 +32,14 @@ QDirIterator* QDirIterator_new3(struct miqt_string path, int filter) { QDirIterator* QDirIterator_new4(struct miqt_string path, struct miqt_array /* of struct miqt_string */ nameFilters) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - return new (std::nothrow) QDirIterator(path_QString, nameFilters_QList); + return new (std::nothrow) QDirIterator(path_QString, nameFilters_QStringList); } QDirIterator* QDirIterator_new5(QDir* dir, int flags) { @@ -58,26 +58,26 @@ QDirIterator* QDirIterator_new7(struct miqt_string path, int filter, int flags) QDirIterator* QDirIterator_new8(struct miqt_string path, struct miqt_array /* of struct miqt_string */ nameFilters, int filters) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - return new (std::nothrow) QDirIterator(path_QString, nameFilters_QList, static_cast(filters)); + return new (std::nothrow) QDirIterator(path_QString, nameFilters_QStringList, static_cast(filters)); } QDirIterator* QDirIterator_new9(struct miqt_string path, struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int flags) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - return new (std::nothrow) QDirIterator(path_QString, nameFilters_QList, static_cast(filters), static_cast(flags)); + return new (std::nothrow) QDirIterator(path_QString, nameFilters_QStringList, static_cast(filters), static_cast(flags)); } struct miqt_string QDirIterator_next(QDirIterator* self) { diff --git a/qt/gen_qdirmodel.cpp b/qt/gen_qdirmodel.cpp index 3065b08a8c..35877e22a5 100644 --- a/qt/gen_qdirmodel.cpp +++ b/qt/gen_qdirmodel.cpp @@ -282,14 +282,14 @@ class MiqtVirtualQDirModel final : public QDirModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QDirModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QDirModel_virtualbase_mimeTypes(const void* self); @@ -305,12 +305,12 @@ class MiqtVirtualQDirModel final : public QDirModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QDirModel_mimeData(this, handle__mimeData, sigval1); @@ -697,13 +697,13 @@ class MiqtVirtualQDirModel final : public QDirModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QDirModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QDirModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -931,14 +931,14 @@ class MiqtVirtualQDirModel final : public QDirModel { }; QDirModel* QDirModel_new(struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int sort) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQDirModel(nameFilters_QList, static_cast(filters), static_cast(sort)); + return new (std::nothrow) MiqtVirtualQDirModel(nameFilters_QStringList, static_cast(filters), static_cast(sort)); } QDirModel* QDirModel_new2() { @@ -946,14 +946,14 @@ QDirModel* QDirModel_new2() { } QDirModel* QDirModel_new3(struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int sort, QObject* parent) { - QStringList nameFilters_QList; - nameFilters_QList.reserve(nameFilters.len); + QStringList nameFilters_QStringList; + nameFilters_QStringList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); - nameFilters_QList.push_back(nameFilters_arr_i_QString); + nameFilters_QStringList.push_back(nameFilters_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQDirModel(nameFilters_QList, static_cast(filters), static_cast(sort), parent); + return new (std::nothrow) MiqtVirtualQDirModel(nameFilters_QStringList, static_cast(filters), static_cast(sort), parent); } QDirModel* QDirModel_new4(QObject* parent) { @@ -1038,8 +1038,8 @@ void QDirModel_sort(QDirModel* self, int column, int order) { struct miqt_array /* of struct miqt_string */ QDirModel_mimeTypes(const QDirModel* self) { QStringList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1050,19 +1050,19 @@ struct miqt_array /* of struct miqt_string */ QDirModel_mimeTypes(const QDirMod _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QDirModel_mimeData(const QDirModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return self->mimeData(indexes_QList); + return self->mimeData(indexes_QModelIndexList); } bool QDirModel_dropMimeData(QDirModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { @@ -1083,21 +1083,21 @@ QFileIconProvider* QDirModel_iconProvider(const QDirModel* self) { } void QDirModel_setNameFilters(QDirModel* self, struct miqt_array /* of struct miqt_string */ filters) { - QStringList filters_QList; - filters_QList.reserve(filters.len); + QStringList filters_QStringList; + filters_QStringList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { QString filters_arr_i_QString = QString::fromUtf8(filters_arr[i].data, filters_arr[i].len); - filters_QList.push_back(filters_arr_i_QString); + filters_QStringList.push_back(filters_arr_i_QString); } - self->setNameFilters(filters_QList); + self->setNameFilters(filters_QStringList); } struct miqt_array /* of struct miqt_string */ QDirModel_nameFilters(const QDirModel* self) { QStringList _ret = self->nameFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1108,7 +1108,7 @@ struct miqt_array /* of struct miqt_string */ QDirModel_nameFilters(const QDirM _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1418,8 +1418,8 @@ bool QDirModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QDirModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QDirModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1430,7 +1430,7 @@ struct miqt_array /* of struct miqt_string */ QDirModel_virtualbase_mimeTypes(c _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1446,13 +1446,13 @@ bool QDirModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QDirModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QDirModel::mimeData(indexes_QList); + return static_cast(self)->QDirModel::mimeData(indexes_QModelIndexList); } bool QDirModel_override_virtual_dropMimeData(void* self, intptr_t slot) { @@ -1728,12 +1728,12 @@ bool QDirModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QDirModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QDirModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1941,13 +1941,13 @@ void QDirModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void* self } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QDirModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2134,19 +2134,19 @@ void QDirModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast_ok, v } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QDirModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2159,12 +2159,12 @@ struct miqt_array /* of QModelIndex* */ QDirModel_protectedbase_persistentIndex *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qeasingcurve.cpp b/qt/gen_qeasingcurve.cpp index 615052118b..9310991256 100644 --- a/qt/gen_qeasingcurve.cpp +++ b/qt/gen_qeasingcurve.cpp @@ -78,12 +78,12 @@ void QEasingCurve_addTCBSegment(QEasingCurve* self, QPointF* nextPoint, double t struct miqt_array /* of QPointF* */ QEasingCurve_toCubicSpline(const QEasingCurve* self) { QVector _ret = self->toCubicSpline(); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qevent.cpp b/qt/gen_qevent.cpp index ec881a261b..b47ecef3c0 100644 --- a/qt/gen_qevent.cpp +++ b/qt/gen_qevent.cpp @@ -1047,12 +1047,12 @@ void QInputMethodEvent_setCommitString(QInputMethodEvent* self, struct miqt_stri struct miqt_array /* of QInputMethodEvent__Attribute* */ QInputMethodEvent_attributes(const QInputMethodEvent* self) { const QList& _ret = self->attributes(); // Convert QList<> from C++ memory to manually-managed C memory - QInputMethodEvent__Attribute** _arr = static_cast(malloc(sizeof(QInputMethodEvent__Attribute*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QInputMethodEvent__Attribute** _arr = static_cast(malloc(sizeof(QInputMethodEvent__Attribute*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QInputMethodEvent::Attribute(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1611,12 +1611,12 @@ int QTouchEvent_touchPointStates(const QTouchEvent* self) { struct miqt_array /* of QTouchEvent__TouchPoint* */ QTouchEvent_touchPoints(const QTouchEvent* self) { const QList& _ret = self->touchPoints(); // Convert QList<> from C++ memory to manually-managed C memory - QTouchEvent__TouchPoint** _arr = static_cast(malloc(sizeof(QTouchEvent__TouchPoint*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTouchEvent__TouchPoint** _arr = static_cast(malloc(sizeof(QTouchEvent__TouchPoint*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTouchEvent::TouchPoint(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1925,12 +1925,12 @@ int QTouchEvent__TouchPoint_flags(const QTouchEvent__TouchPoint* self) { struct miqt_array /* of QPointF* */ QTouchEvent__TouchPoint_rawScreenPositions(const QTouchEvent__TouchPoint* self) { QVector _ret = self->rawScreenPositions(); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2016,13 +2016,13 @@ void QTouchEvent__TouchPoint_setFlags(QTouchEvent__TouchPoint* self, int flags) } void QTouchEvent__TouchPoint_setRawScreenPositions(QTouchEvent__TouchPoint* self, struct miqt_array /* of QPointF* */ positions) { - QVector positions_QList; - positions_QList.reserve(positions.len); + QVector positions_QVector; + positions_QVector.reserve(positions.len); QPointF** positions_arr = static_cast(positions.data); for(size_t i = 0; i < positions.len; ++i) { - positions_QList.push_back(*(positions_arr[i])); + positions_QVector.push_back(*(positions_arr[i])); } - self->setRawScreenPositions(positions_QList); + self->setRawScreenPositions(positions_QVector); } void QTouchEvent__TouchPoint_delete(QTouchEvent__TouchPoint* self) { diff --git a/qt/gen_qfactoryinterface.cpp b/qt/gen_qfactoryinterface.cpp index 4a6a04a811..35f3d99752 100644 --- a/qt/gen_qfactoryinterface.cpp +++ b/qt/gen_qfactoryinterface.cpp @@ -17,8 +17,8 @@ extern "C" { struct miqt_array /* of struct miqt_string */ QFactoryInterface_keys(const QFactoryInterface* self) { QStringList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -29,7 +29,7 @@ struct miqt_array /* of struct miqt_string */ QFactoryInterface_keys(const QFac _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qfiledialog.cpp b/qt/gen_qfiledialog.cpp index 6c592f466b..42b39fd75b 100644 --- a/qt/gen_qfiledialog.cpp +++ b/qt/gen_qfiledialog.cpp @@ -1104,8 +1104,8 @@ void QFileDialog_selectFile(QFileDialog* self, struct miqt_string filename) { struct miqt_array /* of struct miqt_string */ QFileDialog_selectedFiles(const QFileDialog* self) { QStringList _ret = self->selectedFiles(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1116,7 +1116,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_selectedFiles(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1128,12 +1128,12 @@ void QFileDialog_selectUrl(QFileDialog* self, QUrl* url) { struct miqt_array /* of QUrl* */ QFileDialog_selectedUrls(const QFileDialog* self) { QList _ret = self->selectedUrls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1152,21 +1152,21 @@ void QFileDialog_setNameFilter(QFileDialog* self, struct miqt_string filter) { } void QFileDialog_setNameFilters(QFileDialog* self, struct miqt_array /* of struct miqt_string */ filters) { - QStringList filters_QList; - filters_QList.reserve(filters.len); + QStringList filters_QStringList; + filters_QStringList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { QString filters_arr_i_QString = QString::fromUtf8(filters_arr[i].data, filters_arr[i].len); - filters_QList.push_back(filters_arr_i_QString); + filters_QStringList.push_back(filters_arr_i_QString); } - self->setNameFilters(filters_QList); + self->setNameFilters(filters_QStringList); } struct miqt_array /* of struct miqt_string */ QFileDialog_nameFilters(const QFileDialog* self) { QStringList _ret = self->nameFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1177,7 +1177,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_nameFilters(const QFi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1210,21 +1210,21 @@ struct miqt_string QFileDialog_selectedNameFilter(const QFileDialog* self) { } void QFileDialog_setMimeTypeFilters(QFileDialog* self, struct miqt_array /* of struct miqt_string */ filters) { - QStringList filters_QList; - filters_QList.reserve(filters.len); + QStringList filters_QStringList; + filters_QStringList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { QString filters_arr_i_QString = QString::fromUtf8(filters_arr[i].data, filters_arr[i].len); - filters_QList.push_back(filters_arr_i_QString); + filters_QStringList.push_back(filters_arr_i_QString); } - self->setMimeTypeFilters(filters_QList); + self->setMimeTypeFilters(filters_QStringList); } struct miqt_array /* of struct miqt_string */ QFileDialog_mimeTypeFilters(const QFileDialog* self) { QStringList _ret = self->mimeTypeFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1235,7 +1235,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_mimeTypeFilters(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1310,12 +1310,12 @@ void QFileDialog_setSidebarUrls(QFileDialog* self, struct miqt_array /* of QUrl* struct miqt_array /* of QUrl* */ QFileDialog_sidebarUrls(const QFileDialog* self) { QList _ret = self->sidebarUrls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1359,21 +1359,21 @@ struct miqt_string QFileDialog_defaultSuffix(const QFileDialog* self) { } void QFileDialog_setHistory(QFileDialog* self, struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; - paths_QList.reserve(paths.len); + QStringList paths_QStringList; + paths_QStringList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { QString paths_arr_i_QString = QString::fromUtf8(paths_arr[i].data, paths_arr[i].len); - paths_QList.push_back(paths_arr_i_QString); + paths_QStringList.push_back(paths_arr_i_QString); } - self->setHistory(paths_QList); + self->setHistory(paths_QStringList); } struct miqt_array /* of struct miqt_string */ QFileDialog_history(const QFileDialog* self) { QStringList _ret = self->history(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1384,7 +1384,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_history(const QFileDi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1422,21 +1422,21 @@ struct miqt_string QFileDialog_labelText(const QFileDialog* self, int label) { } void QFileDialog_setSupportedSchemes(QFileDialog* self, struct miqt_array /* of struct miqt_string */ schemes) { - QStringList schemes_QList; - schemes_QList.reserve(schemes.len); + QStringList schemes_QStringList; + schemes_QStringList.reserve(schemes.len); struct miqt_string* schemes_arr = static_cast(schemes.data); for(size_t i = 0; i < schemes.len; ++i) { QString schemes_arr_i_QString = QString::fromUtf8(schemes_arr[i].data, schemes_arr[i].len); - schemes_QList.push_back(schemes_arr_i_QString); + schemes_QStringList.push_back(schemes_arr_i_QString); } - self->setSupportedSchemes(schemes_QList); + self->setSupportedSchemes(schemes_QStringList); } struct miqt_array /* of struct miqt_string */ QFileDialog_supportedSchemes(const QFileDialog* self) { QStringList _ret = self->supportedSchemes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1447,7 +1447,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_supportedSchemes(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1501,22 +1501,22 @@ void QFileDialog_connect_fileSelected(QFileDialog* self, intptr_t slot) { } void QFileDialog_filesSelected(QFileDialog* self, struct miqt_array /* of struct miqt_string */ files) { - QStringList files_QList; - files_QList.reserve(files.len); + QStringList files_QStringList; + files_QStringList.reserve(files.len); struct miqt_string* files_arr = static_cast(files.data); for(size_t i = 0; i < files.len; ++i) { QString files_arr_i_QString = QString::fromUtf8(files_arr[i].data, files_arr[i].len); - files_QList.push_back(files_arr_i_QString); + files_QStringList.push_back(files_arr_i_QString); } - self->filesSelected(files_QList); + self->filesSelected(files_QStringList); } void QFileDialog_connect_filesSelected(QFileDialog* self, intptr_t slot) { QFileDialog::connect(self, static_cast(&QFileDialog::filesSelected), self, [=](const QStringList& files) { const QStringList& files_ret = files; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* files_arr = static_cast(malloc(sizeof(struct miqt_string) * files_ret.length())); - for (size_t i = 0, e = files_ret.length(); i < e; ++i) { + struct miqt_string* files_arr = static_cast(malloc(sizeof(struct miqt_string) * files_ret.size())); + for (size_t i = 0, e = files_ret.size(); i < e; ++i) { QString files_lv_ret = files_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray files_lv_b = files_lv_ret.toUtf8(); @@ -1527,7 +1527,7 @@ void QFileDialog_connect_filesSelected(QFileDialog* self, intptr_t slot) { files_arr[i] = files_lv_ms; } struct miqt_array files_out; - files_out.len = files_ret.length(); + files_out.len = files_ret.size(); files_out.data = static_cast(files_arr); struct miqt_array /* of struct miqt_string */ sigval1 = files_out; miqt_exec_callback_QFileDialog_filesSelected(slot, sigval1); @@ -1599,12 +1599,12 @@ void QFileDialog_connect_urlsSelected(QFileDialog* self, intptr_t slot) { QFileDialog::connect(self, static_cast&)>(&QFileDialog::urlsSelected), self, [=](const QList& urls) { const QList& urls_ret = urls; // Convert QList<> from C++ memory to manually-managed C memory - QUrl** urls_arr = static_cast(malloc(sizeof(QUrl*) * urls_ret.length())); - for (size_t i = 0, e = urls_ret.length(); i < e; ++i) { + QUrl** urls_arr = static_cast(malloc(sizeof(QUrl*) * urls_ret.size())); + for (size_t i = 0, e = urls_ret.size(); i < e; ++i) { urls_arr[i] = new QUrl(urls_ret[i]); } struct miqt_array urls_out; - urls_out.len = urls_ret.length(); + urls_out.len = urls_ret.size(); urls_out.data = static_cast(urls_arr); struct miqt_array /* of QUrl* */ sigval1 = urls_out; miqt_exec_callback_QFileDialog_urlsSelected(slot, sigval1); @@ -1704,8 +1704,8 @@ QUrl* QFileDialog_getExistingDirectoryUrl() { struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames() { QStringList _ret = QFileDialog::getOpenFileNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1716,7 +1716,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1724,12 +1724,12 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames() { struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls() { QList _ret = QFileDialog::getOpenFileUrls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1998,21 +1998,21 @@ QUrl* QFileDialog_getExistingDirectoryUrl4(QWidget* parent, struct miqt_string c QUrl* QFileDialog_getExistingDirectoryUrl5(QWidget* parent, struct miqt_string caption, QUrl* dir, int options, struct miqt_array /* of struct miqt_string */ supportedSchemes) { QString caption_QString = QString::fromUtf8(caption.data, caption.len); - QStringList supportedSchemes_QList; - supportedSchemes_QList.reserve(supportedSchemes.len); + QStringList supportedSchemes_QStringList; + supportedSchemes_QStringList.reserve(supportedSchemes.len); struct miqt_string* supportedSchemes_arr = static_cast(supportedSchemes.data); for(size_t i = 0; i < supportedSchemes.len; ++i) { QString supportedSchemes_arr_i_QString = QString::fromUtf8(supportedSchemes_arr[i].data, supportedSchemes_arr[i].len); - supportedSchemes_QList.push_back(supportedSchemes_arr_i_QString); + supportedSchemes_QStringList.push_back(supportedSchemes_arr_i_QString); } - return new QUrl(QFileDialog::getExistingDirectoryUrl(parent, caption_QString, *dir, static_cast(options), supportedSchemes_QList)); + return new QUrl(QFileDialog::getExistingDirectoryUrl(parent, caption_QString, *dir, static_cast(options), supportedSchemes_QStringList)); } struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNamesWithParent(QWidget* parent) { QStringList _ret = QFileDialog::getOpenFileNames(parent); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2023,7 +2023,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNamesWithP _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2032,8 +2032,8 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames2(QWi QString caption_QString = QString::fromUtf8(caption.data, caption.len); QStringList _ret = QFileDialog::getOpenFileNames(parent, caption_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2044,7 +2044,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames2(QWi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2054,8 +2054,8 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames3(QWi QString dir_QString = QString::fromUtf8(dir.data, dir.len); QStringList _ret = QFileDialog::getOpenFileNames(parent, caption_QString, dir_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2066,7 +2066,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames3(QWi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2077,8 +2077,8 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames4(QWi QString filter_QString = QString::fromUtf8(filter.data, filter.len); QStringList _ret = QFileDialog::getOpenFileNames(parent, caption_QString, dir_QString, filter_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2089,7 +2089,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames4(QWi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2097,12 +2097,12 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames4(QWi struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrlsWithParent(QWidget* parent) { QList _ret = QFileDialog::getOpenFileUrls(parent); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2111,12 +2111,12 @@ struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls2(QWidget* parent, QString caption_QString = QString::fromUtf8(caption.data, caption.len); QList _ret = QFileDialog::getOpenFileUrls(parent, caption_QString); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2125,12 +2125,12 @@ struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls3(QWidget* parent, QString caption_QString = QString::fromUtf8(caption.data, caption.len); QList _ret = QFileDialog::getOpenFileUrls(parent, caption_QString, *dir); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2140,12 +2140,12 @@ struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls4(QWidget* parent, QString filter_QString = QString::fromUtf8(filter.data, filter.len); QList _ret = QFileDialog::getOpenFileUrls(parent, caption_QString, *dir, filter_QString); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qfileselector.cpp b/qt/gen_qfileselector.cpp index 8746f4b735..31e5add7d0 100644 --- a/qt/gen_qfileselector.cpp +++ b/qt/gen_qfileselector.cpp @@ -226,8 +226,8 @@ QUrl* QFileSelector_selectWithFilePath(const QFileSelector* self, QUrl* filePath struct miqt_array /* of struct miqt_string */ QFileSelector_extraSelectors(const QFileSelector* self) { QStringList _ret = self->extraSelectors(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -238,27 +238,27 @@ struct miqt_array /* of struct miqt_string */ QFileSelector_extraSelectors(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QFileSelector_setExtraSelectors(QFileSelector* self, struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; - list_QList.reserve(list.len); + QStringList list_QStringList; + list_QStringList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { QString list_arr_i_QString = QString::fromUtf8(list_arr[i].data, list_arr[i].len); - list_QList.push_back(list_arr_i_QString); + list_QStringList.push_back(list_arr_i_QString); } - self->setExtraSelectors(list_QList); + self->setExtraSelectors(list_QStringList); } struct miqt_array /* of struct miqt_string */ QFileSelector_allSelectors(const QFileSelector* self) { QStringList _ret = self->allSelectors(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -269,7 +269,7 @@ struct miqt_array /* of struct miqt_string */ QFileSelector_allSelectors(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qfilesystemmodel.cpp b/qt/gen_qfilesystemmodel.cpp index 24c78eb16f..1c5ea8b918 100644 --- a/qt/gen_qfilesystemmodel.cpp +++ b/qt/gen_qfilesystemmodel.cpp @@ -342,14 +342,14 @@ class MiqtVirtualQFileSystemModel final : public QFileSystemModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QFileSystemModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QFileSystemModel_virtualbase_mimeTypes(const void* self); @@ -365,12 +365,12 @@ class MiqtVirtualQFileSystemModel final : public QFileSystemModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QFileSystemModel_mimeData(this, handle__mimeData, sigval1); @@ -733,13 +733,13 @@ class MiqtVirtualQFileSystemModel final : public QFileSystemModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QFileSystemModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QFileSystemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -1115,8 +1115,8 @@ void QFileSystemModel_sort(QFileSystemModel* self, int column, int order) { struct miqt_array /* of struct miqt_string */ QFileSystemModel_mimeTypes(const QFileSystemModel* self) { QStringList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1127,19 +1127,19 @@ struct miqt_array /* of struct miqt_string */ QFileSystemModel_mimeTypes(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QFileSystemModel_mimeData(const QFileSystemModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return self->mimeData(indexes_QList); + return self->mimeData(indexes_QModelIndexList); } bool QFileSystemModel_dropMimeData(QFileSystemModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { @@ -1213,21 +1213,21 @@ bool QFileSystemModel_nameFilterDisables(const QFileSystemModel* self) { } void QFileSystemModel_setNameFilters(QFileSystemModel* self, struct miqt_array /* of struct miqt_string */ filters) { - QStringList filters_QList; - filters_QList.reserve(filters.len); + QStringList filters_QStringList; + filters_QStringList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { QString filters_arr_i_QString = QString::fromUtf8(filters_arr[i].data, filters_arr[i].len); - filters_QList.push_back(filters_arr_i_QString); + filters_QStringList.push_back(filters_arr_i_QString); } - self->setNameFilters(filters_QList); + self->setNameFilters(filters_QStringList); } struct miqt_array /* of struct miqt_string */ QFileSystemModel_nameFilters(const QFileSystemModel* self) { QStringList _ret = self->nameFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1238,7 +1238,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemModel_nameFilters(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1585,8 +1585,8 @@ bool QFileSystemModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QFileSystemModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QFileSystemModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1597,7 +1597,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemModel_virtualbase_mime _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1613,13 +1613,13 @@ bool QFileSystemModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QFileSystemModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QFileSystemModel::mimeData(indexes_QList); + return static_cast(self)->QFileSystemModel::mimeData(indexes_QModelIndexList); } bool QFileSystemModel_override_virtual_dropMimeData(void* self, intptr_t slot) { @@ -1881,12 +1881,12 @@ bool QFileSystemModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QFileSystemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QFileSystemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2066,13 +2066,13 @@ void QFileSystemModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const voi } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QFileSystemModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2259,19 +2259,19 @@ void QFileSystemModel_protectedbase_changePersistentIndexList(bool* _dynamic_cas } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QFileSystemModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2284,12 +2284,12 @@ struct miqt_array /* of QModelIndex* */ QFileSystemModel_protectedbase_persiste *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qfilesystemwatcher.cpp b/qt/gen_qfilesystemwatcher.cpp index 02d491909f..8637719939 100644 --- a/qt/gen_qfilesystemwatcher.cpp +++ b/qt/gen_qfilesystemwatcher.cpp @@ -173,14 +173,14 @@ QFileSystemWatcher* QFileSystemWatcher_new() { } QFileSystemWatcher* QFileSystemWatcher_new2(struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; - paths_QList.reserve(paths.len); + QStringList paths_QStringList; + paths_QStringList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { QString paths_arr_i_QString = QString::fromUtf8(paths_arr[i].data, paths_arr[i].len); - paths_QList.push_back(paths_arr_i_QString); + paths_QStringList.push_back(paths_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQFileSystemWatcher(paths_QList); + return new (std::nothrow) MiqtVirtualQFileSystemWatcher(paths_QStringList); } QFileSystemWatcher* QFileSystemWatcher_new3(QObject* parent) { @@ -188,14 +188,14 @@ QFileSystemWatcher* QFileSystemWatcher_new3(QObject* parent) { } QFileSystemWatcher* QFileSystemWatcher_new4(struct miqt_array /* of struct miqt_string */ paths, QObject* parent) { - QStringList paths_QList; - paths_QList.reserve(paths.len); + QStringList paths_QStringList; + paths_QStringList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { QString paths_arr_i_QString = QString::fromUtf8(paths_arr[i].data, paths_arr[i].len); - paths_QList.push_back(paths_arr_i_QString); + paths_QStringList.push_back(paths_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQFileSystemWatcher(paths_QList, parent); + return new (std::nothrow) MiqtVirtualQFileSystemWatcher(paths_QStringList, parent); } void QFileSystemWatcher_virtbase(QFileSystemWatcher* src, QObject** outptr_QObject) { @@ -238,17 +238,17 @@ bool QFileSystemWatcher_addPath(QFileSystemWatcher* self, struct miqt_string fil } struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_addPaths(QFileSystemWatcher* self, struct miqt_array /* of struct miqt_string */ files) { - QStringList files_QList; - files_QList.reserve(files.len); + QStringList files_QStringList; + files_QStringList.reserve(files.len); struct miqt_string* files_arr = static_cast(files.data); for(size_t i = 0; i < files.len; ++i) { QString files_arr_i_QString = QString::fromUtf8(files_arr[i].data, files_arr[i].len); - files_QList.push_back(files_arr_i_QString); + files_QStringList.push_back(files_arr_i_QString); } - QStringList _ret = self->addPaths(files_QList); + QStringList _ret = self->addPaths(files_QStringList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -259,7 +259,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_addPaths(QFile _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -270,17 +270,17 @@ bool QFileSystemWatcher_removePath(QFileSystemWatcher* self, struct miqt_string } struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_removePaths(QFileSystemWatcher* self, struct miqt_array /* of struct miqt_string */ files) { - QStringList files_QList; - files_QList.reserve(files.len); + QStringList files_QStringList; + files_QStringList.reserve(files.len); struct miqt_string* files_arr = static_cast(files.data); for(size_t i = 0; i < files.len; ++i) { QString files_arr_i_QString = QString::fromUtf8(files_arr[i].data, files_arr[i].len); - files_QList.push_back(files_arr_i_QString); + files_QStringList.push_back(files_arr_i_QString); } - QStringList _ret = self->removePaths(files_QList); + QStringList _ret = self->removePaths(files_QStringList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -291,7 +291,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_removePaths(QF _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -299,8 +299,8 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_removePaths(QF struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_files(const QFileSystemWatcher* self) { QStringList _ret = self->files(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -311,7 +311,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_files(const QF _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -319,8 +319,8 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_files(const QF struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_directories(const QFileSystemWatcher* self) { QStringList _ret = self->directories(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -331,7 +331,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_directories(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qfont.cpp b/qt/gen_qfont.cpp index c28ae7089d..1796208f73 100644 --- a/qt/gen_qfont.cpp +++ b/qt/gen_qfont.cpp @@ -75,8 +75,8 @@ void QFont_setFamily(QFont* self, struct miqt_string family) { struct miqt_array /* of struct miqt_string */ QFont_families(const QFont* self) { QStringList _ret = self->families(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -87,20 +87,20 @@ struct miqt_array /* of struct miqt_string */ QFont_families(const QFont* self) _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QFont_setFamilies(QFont* self, struct miqt_array /* of struct miqt_string */ families) { - QStringList families_QList; - families_QList.reserve(families.len); + QStringList families_QStringList; + families_QStringList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { QString families_arr_i_QString = QString::fromUtf8(families_arr[i].data, families_arr[i].len); - families_QList.push_back(families_arr_i_QString); + families_QStringList.push_back(families_arr_i_QString); } - self->setFamilies(families_QList); + self->setFamilies(families_QStringList); } struct miqt_string QFont_styleName(const QFont* self) { @@ -379,8 +379,8 @@ struct miqt_array /* of struct miqt_string */ QFont_substitutes(struct miqt_str QString param1_QString = QString::fromUtf8(param1.data, param1.len); QStringList _ret = QFont::substitutes(param1_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -391,7 +391,7 @@ struct miqt_array /* of struct miqt_string */ QFont_substitutes(struct miqt_str _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -399,8 +399,8 @@ struct miqt_array /* of struct miqt_string */ QFont_substitutes(struct miqt_str struct miqt_array /* of struct miqt_string */ QFont_substitutions() { QStringList _ret = QFont::substitutions(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -411,7 +411,7 @@ struct miqt_array /* of struct miqt_string */ QFont_substitutions() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -424,14 +424,14 @@ void QFont_insertSubstitution(struct miqt_string param1, struct miqt_string para void QFont_insertSubstitutions(struct miqt_string param1, struct miqt_array /* of struct miqt_string */ param2) { QString param1_QString = QString::fromUtf8(param1.data, param1.len); - QStringList param2_QList; - param2_QList.reserve(param2.len); + QStringList param2_QStringList; + param2_QStringList.reserve(param2.len); struct miqt_string* param2_arr = static_cast(param2.data); for(size_t i = 0; i < param2.len; ++i) { QString param2_arr_i_QString = QString::fromUtf8(param2_arr[i].data, param2_arr[i].len); - param2_QList.push_back(param2_arr_i_QString); + param2_QStringList.push_back(param2_arr_i_QString); } - QFont::insertSubstitutions(param1_QString, param2_QList); + QFont::insertSubstitutions(param1_QString, param2_QStringList); } void QFont_removeSubstitutions(struct miqt_string param1) { diff --git a/qt/gen_qfontdatabase.cpp b/qt/gen_qfontdatabase.cpp index ed7267d46b..0f28f8f9a0 100644 --- a/qt/gen_qfontdatabase.cpp +++ b/qt/gen_qfontdatabase.cpp @@ -24,12 +24,12 @@ QFontDatabase* QFontDatabase_new() { struct miqt_array /* of int */ QFontDatabase_standardSizes() { QList _ret = QFontDatabase::standardSizes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -37,13 +37,13 @@ struct miqt_array /* of int */ QFontDatabase_standardSizes() { struct miqt_array /* of int */ QFontDatabase_writingSystems(const QFontDatabase* self) { QList _ret = self->writingSystems(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QFontDatabase::WritingSystem _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -52,13 +52,13 @@ struct miqt_array /* of int */ QFontDatabase_writingSystemsWithFamily(const QFo QString family_QString = QString::fromUtf8(family.data, family.len); QList _ret = self->writingSystems(family_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QFontDatabase::WritingSystem _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -66,8 +66,8 @@ struct miqt_array /* of int */ QFontDatabase_writingSystemsWithFamily(const QFo struct miqt_array /* of struct miqt_string */ QFontDatabase_families(const QFontDatabase* self) { QStringList _ret = self->families(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -78,7 +78,7 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_families(const QFon _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -87,8 +87,8 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_styles(const QFontD QString family_QString = QString::fromUtf8(family.data, family.len); QStringList _ret = self->styles(family_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -99,7 +99,7 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_styles(const QFontD _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -108,12 +108,12 @@ struct miqt_array /* of int */ QFontDatabase_pointSizes(QFontDatabase* self, st QString family_QString = QString::fromUtf8(family.data, family.len); QList _ret = self->pointSizes(family_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -123,12 +123,12 @@ struct miqt_array /* of int */ QFontDatabase_smoothSizes(QFontDatabase* self, s QString style_QString = QString::fromUtf8(style.data, style.len); QList _ret = self->smoothSizes(family_QString, style_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -244,8 +244,8 @@ int QFontDatabase_addApplicationFontFromData(struct miqt_string fontData) { struct miqt_array /* of struct miqt_string */ QFontDatabase_applicationFontFamilies(int id) { QStringList _ret = QFontDatabase::applicationFontFamilies(static_cast(id)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -256,7 +256,7 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_applicationFontFami _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -280,8 +280,8 @@ QFont* QFontDatabase_systemFont(int type) { struct miqt_array /* of struct miqt_string */ QFontDatabase_familiesWithWritingSystem(const QFontDatabase* self, int writingSystem) { QStringList _ret = self->families(static_cast(writingSystem)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -292,7 +292,7 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_familiesWithWriting _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -302,12 +302,12 @@ struct miqt_array /* of int */ QFontDatabase_pointSizes2(QFontDatabase* self, s QString style_QString = QString::fromUtf8(style.data, style.len); QList _ret = self->pointSizes(family_QString, style_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qgenericpluginfactory.cpp b/qt/gen_qgenericpluginfactory.cpp index beb05cec64..e25a91e87a 100644 --- a/qt/gen_qgenericpluginfactory.cpp +++ b/qt/gen_qgenericpluginfactory.cpp @@ -18,8 +18,8 @@ extern "C" { struct miqt_array /* of struct miqt_string */ QGenericPluginFactory_keys() { QStringList _ret = QGenericPluginFactory::keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -30,7 +30,7 @@ struct miqt_array /* of struct miqt_string */ QGenericPluginFactory_keys() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qgesture.cpp b/qt/gen_qgesture.cpp index 1e68d24622..2559127d93 100644 --- a/qt/gen_qgesture.cpp +++ b/qt/gen_qgesture.cpp @@ -2508,12 +2508,12 @@ void QGestureEvent_virtbase(QGestureEvent* src, QEvent** outptr_QEvent) { struct miqt_array /* of QGesture* */ QGestureEvent_gestures(const QGestureEvent* self) { QList _ret = self->gestures(); // Convert QList<> from C++ memory to manually-managed C memory - QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2525,12 +2525,12 @@ QGesture* QGestureEvent_gesture(const QGestureEvent* self, int type) { struct miqt_array /* of QGesture* */ QGestureEvent_activeGestures(const QGestureEvent* self) { QList _ret = self->activeGestures(); // Convert QList<> from C++ memory to manually-managed C memory - QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2538,12 +2538,12 @@ struct miqt_array /* of QGesture* */ QGestureEvent_activeGestures(const QGestur struct miqt_array /* of QGesture* */ QGestureEvent_canceledGestures(const QGestureEvent* self) { QList _ret = self->canceledGestures(); // Convert QList<> from C++ memory to manually-managed C memory - QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qglyphrun.cpp b/qt/gen_qglyphrun.cpp index 7270f163a4..530229de3c 100644 --- a/qt/gen_qglyphrun.cpp +++ b/qt/gen_qglyphrun.cpp @@ -45,47 +45,47 @@ void QGlyphRun_setRawData(QGlyphRun* self, const unsigned int* glyphIndexArray, struct miqt_array /* of unsigned int */ QGlyphRun_glyphIndexes(const QGlyphRun* self) { QVector _ret = self->glyphIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QGlyphRun_setGlyphIndexes(QGlyphRun* self, struct miqt_array /* of unsigned int */ glyphIndexes) { - QVector glyphIndexes_QList; - glyphIndexes_QList.reserve(glyphIndexes.len); + QVector glyphIndexes_QVector; + glyphIndexes_QVector.reserve(glyphIndexes.len); unsigned int* glyphIndexes_arr = static_cast(glyphIndexes.data); for(size_t i = 0; i < glyphIndexes.len; ++i) { - glyphIndexes_QList.push_back(static_cast(glyphIndexes_arr[i])); + glyphIndexes_QVector.push_back(static_cast(glyphIndexes_arr[i])); } - self->setGlyphIndexes(glyphIndexes_QList); + self->setGlyphIndexes(glyphIndexes_QVector); } struct miqt_array /* of QPointF* */ QGlyphRun_positions(const QGlyphRun* self) { QVector _ret = self->positions(); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QGlyphRun_setPositions(QGlyphRun* self, struct miqt_array /* of QPointF* */ positions) { - QVector positions_QList; - positions_QList.reserve(positions.len); + QVector positions_QVector; + positions_QVector.reserve(positions.len); QPointF** positions_arr = static_cast(positions.data); for(size_t i = 0; i < positions.len; ++i) { - positions_QList.push_back(*(positions_arr[i])); + positions_QVector.push_back(*(positions_arr[i])); } - self->setPositions(positions_QList); + self->setPositions(positions_QVector); } void QGlyphRun_clear(QGlyphRun* self) { diff --git a/qt/gen_qgraphicsitem.cpp b/qt/gen_qgraphicsitem.cpp index ce5380d96b..ac28e055ba 100644 --- a/qt/gen_qgraphicsitem.cpp +++ b/qt/gen_qgraphicsitem.cpp @@ -1168,12 +1168,12 @@ void QGraphicsItem_setParentItem(QGraphicsItem* self, QGraphicsItem* parent) { struct miqt_array /* of QGraphicsItem* */ QGraphicsItem_childItems(const QGraphicsItem* self) { QList _ret = self->childItems(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1539,12 +1539,12 @@ double QGraphicsItem_scale(const QGraphicsItem* self) { struct miqt_array /* of QGraphicsTransform* */ QGraphicsItem_transformations(const QGraphicsItem* self) { QList _ret = self->transformations(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsTransform** _arr = static_cast(malloc(sizeof(QGraphicsTransform*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsTransform** _arr = static_cast(malloc(sizeof(QGraphicsTransform*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1627,12 +1627,12 @@ bool QGraphicsItem_collidesWithPath(const QGraphicsItem* self, QPainterPath* pat struct miqt_array /* of QGraphicsItem* */ QGraphicsItem_collidingItems(const QGraphicsItem* self) { QList _ret = self->collidingItems(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1890,12 +1890,12 @@ void QGraphicsItem_setTransform2(QGraphicsItem* self, QTransform* matrix, bool c struct miqt_array /* of QGraphicsItem* */ QGraphicsItem_collidingItemsWithMode(const QGraphicsItem* self, int mode) { QList _ret = self->collidingItems(static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qgraphicsitemanimation.cpp b/qt/gen_qgraphicsitemanimation.cpp index f20ff5d2fe..4723504089 100644 --- a/qt/gen_qgraphicsitemanimation.cpp +++ b/qt/gen_qgraphicsitemanimation.cpp @@ -273,8 +273,8 @@ QPointF* QGraphicsItemAnimation_posAt(const QGraphicsItemAnimation* self, double struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_posList(const QGraphicsItemAnimation* self) { QList> _ret = self->posList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -288,7 +288,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -313,8 +313,8 @@ double QGraphicsItemAnimation_rotationAt(const QGraphicsItemAnimation* self, dou struct miqt_array /* of struct miqt_map tuple of double and double */ QGraphicsItemAnimation_rotationList(const QGraphicsItemAnimation* self) { QList> _ret = self->rotationList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and double */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and double */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and double */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and double */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -328,7 +328,7 @@ struct miqt_array /* of struct miqt_map tuple of double and double */ QGraph _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -350,8 +350,8 @@ double QGraphicsItemAnimation_yTranslationAt(const QGraphicsItemAnimation* self, struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_translationList(const QGraphicsItemAnimation* self) { QList> _ret = self->translationList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -365,7 +365,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -387,8 +387,8 @@ double QGraphicsItemAnimation_horizontalScaleAt(const QGraphicsItemAnimation* se struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_scaleList(const QGraphicsItemAnimation* self) { QList> _ret = self->scaleList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -402,7 +402,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -424,8 +424,8 @@ double QGraphicsItemAnimation_horizontalShearAt(const QGraphicsItemAnimation* se struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_shearList(const QGraphicsItemAnimation* self) { QList> _ret = self->shearList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -439,7 +439,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qgraphicsscene.cpp b/qt/gen_qgraphicsscene.cpp index 4265eb78e3..67e016a0bb 100644 --- a/qt/gen_qgraphicsscene.cpp +++ b/qt/gen_qgraphicsscene.cpp @@ -671,12 +671,12 @@ QRectF* QGraphicsScene_itemsBoundingRect(const QGraphicsScene* self) { struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items(const QGraphicsScene* self) { QList _ret = self->items(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -684,12 +684,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items(const QGraphicsS struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithPos(const QGraphicsScene* self, QPointF* pos) { QList _ret = self->items(*pos); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -697,12 +697,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithPos(const QGr struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithRect(const QGraphicsScene* self, QRectF* rect) { QList _ret = self->items(*rect); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -710,12 +710,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithRect(const QG struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithPath(const QGraphicsScene* self, QPainterPath* path) { QList _ret = self->items(*path); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -723,12 +723,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithPath(const QG struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_collidingItems(const QGraphicsScene* self, QGraphicsItem* item) { QList _ret = self->collidingItems(item); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -740,12 +740,12 @@ QGraphicsItem* QGraphicsScene_itemAt(const QGraphicsScene* self, QPointF* pos, Q struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items2(const QGraphicsScene* self, double x, double y, double w, double h, int mode, int order) { QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -757,12 +757,12 @@ QGraphicsItem* QGraphicsScene_itemAt2(const QGraphicsScene* self, double x, doub struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_selectedItems(const QGraphicsScene* self) { QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -906,12 +906,12 @@ QVariant* QGraphicsScene_inputMethodQuery(const QGraphicsScene* self, int query) struct miqt_array /* of QGraphicsView* */ QGraphicsScene_views(const QGraphicsScene* self) { QList _ret = self->views(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsView** _arr = static_cast(malloc(sizeof(QGraphicsView*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsView** _arr = static_cast(malloc(sizeof(QGraphicsView*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1023,12 +1023,12 @@ void QGraphicsScene_connect_changed(QGraphicsScene* self, intptr_t slot) { QGraphicsScene::connect(self, static_cast&)>(&QGraphicsScene::changed), self, [=](const QList& region) { const QList& region_ret = region; // Convert QList<> from C++ memory to manually-managed C memory - QRectF** region_arr = static_cast(malloc(sizeof(QRectF*) * region_ret.length())); - for (size_t i = 0, e = region_ret.length(); i < e; ++i) { + QRectF** region_arr = static_cast(malloc(sizeof(QRectF*) * region_ret.size())); + for (size_t i = 0, e = region_ret.size(); i < e; ++i) { region_arr[i] = new QRectF(region_ret[i]); } struct miqt_array region_out; - region_out.len = region_ret.length(); + region_out.len = region_ret.size(); region_out.data = static_cast(region_arr); struct miqt_array /* of QRectF* */ sigval1 = region_out; miqt_exec_callback_QGraphicsScene_changed(slot, sigval1); @@ -1131,12 +1131,12 @@ void QGraphicsScene_render4(QGraphicsScene* self, QPainter* painter, QRectF* tar struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithOrder(const QGraphicsScene* self, int order) { QList _ret = self->items(static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1144,12 +1144,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithOrder(const Q struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items3(const QGraphicsScene* self, QPointF* pos, int mode) { QList _ret = self->items(*pos, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1157,12 +1157,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items3(const QGraphics struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items4(const QGraphicsScene* self, QPointF* pos, int mode, int order) { QList _ret = self->items(*pos, static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1170,12 +1170,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items4(const QGraphics struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items5(const QGraphicsScene* self, QPointF* pos, int mode, int order, QTransform* deviceTransform) { QList _ret = self->items(*pos, static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1183,12 +1183,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items5(const QGraphics struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items6(const QGraphicsScene* self, QRectF* rect, int mode) { QList _ret = self->items(*rect, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1196,12 +1196,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items6(const QGraphics struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items7(const QGraphicsScene* self, QRectF* rect, int mode, int order) { QList _ret = self->items(*rect, static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1209,12 +1209,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items7(const QGraphics struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items8(const QGraphicsScene* self, QRectF* rect, int mode, int order, QTransform* deviceTransform) { QList _ret = self->items(*rect, static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1222,12 +1222,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items8(const QGraphics struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items12(const QGraphicsScene* self, QPainterPath* path, int mode) { QList _ret = self->items(*path, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1235,12 +1235,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items12(const QGraphic struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items13(const QGraphicsScene* self, QPainterPath* path, int mode, int order) { QList _ret = self->items(*path, static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1248,12 +1248,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items13(const QGraphic struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items14(const QGraphicsScene* self, QPainterPath* path, int mode, int order, QTransform* deviceTransform) { QList _ret = self->items(*path, static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1261,12 +1261,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items14(const QGraphic struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_collidingItems2(const QGraphicsScene* self, QGraphicsItem* item, int mode) { QList _ret = self->collidingItems(item, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1274,12 +1274,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_collidingItems2(const struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items15(const QGraphicsScene* self, double x, double y, double w, double h, int mode, int order, QTransform* deviceTransform) { QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qgraphicsview.cpp b/qt/gen_qgraphicsview.cpp index 28748c5c68..3822a50658 100644 --- a/qt/gen_qgraphicsview.cpp +++ b/qt/gen_qgraphicsview.cpp @@ -1308,12 +1308,12 @@ void QGraphicsView_render(QGraphicsView* self, QPainter* painter) { struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items(const QGraphicsView* self) { QList _ret = self->items(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1321,12 +1321,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items(const QGraphicsVi struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithPos(const QGraphicsView* self, QPoint* pos) { QList _ret = self->items(*pos); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1334,12 +1334,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithPos(const QGra struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items2(const QGraphicsView* self, int x, int y) { QList _ret = self->items(static_cast(x), static_cast(y)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1347,12 +1347,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items2(const QGraphicsV struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithRect(const QGraphicsView* self, QRect* rect) { QList _ret = self->items(*rect); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1360,12 +1360,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithRect(const QGr struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items3(const QGraphicsView* self, int x, int y, int w, int h) { QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1373,12 +1373,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items3(const QGraphicsV struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithPath(const QGraphicsView* self, QPainterPath* path) { QList _ret = self->items(*path); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1577,12 +1577,12 @@ void QGraphicsView_render4(QGraphicsView* self, QPainter* painter, QRectF* targe struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items4(const QGraphicsView* self, QRect* rect, int mode) { QList _ret = self->items(*rect, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1590,12 +1590,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items4(const QGraphicsV struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items5(const QGraphicsView* self, int x, int y, int w, int h, int mode) { QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1603,12 +1603,12 @@ struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items5(const QGraphicsV struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items7(const QGraphicsView* self, QPainterPath* path, int mode) { QList _ret = self->items(*path, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qgraphicswidget.cpp b/qt/gen_qgraphicswidget.cpp index c56156f288..43f5304871 100644 --- a/qt/gen_qgraphicswidget.cpp +++ b/qt/gen_qgraphicswidget.cpp @@ -1504,12 +1504,12 @@ void QGraphicsWidget_removeAction(QGraphicsWidget* self, QAction* action) { struct miqt_array /* of QAction* */ QGraphicsWidget_actions(const QGraphicsWidget* self) { QList _ret = self->actions(); // Convert QList<> from C++ memory to manually-managed C memory - QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qguiapplication.cpp b/qt/gen_qguiapplication.cpp index c9de41f8ac..ff166bb0cd 100644 --- a/qt/gen_qguiapplication.cpp +++ b/qt/gen_qguiapplication.cpp @@ -285,12 +285,12 @@ struct miqt_string QGuiApplication_desktopFileName() { struct miqt_array /* of QWindow* */ QGuiApplication_allWindows() { QWindowList _ret = QGuiApplication::allWindows(); // Convert QList<> from C++ memory to manually-managed C memory - QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -298,12 +298,12 @@ struct miqt_array /* of QWindow* */ QGuiApplication_allWindows() { struct miqt_array /* of QWindow* */ QGuiApplication_topLevelWindows() { QWindowList _ret = QGuiApplication::topLevelWindows(); // Convert QList<> from C++ memory to manually-managed C memory - QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -350,12 +350,12 @@ QScreen* QGuiApplication_primaryScreen() { struct miqt_array /* of QScreen* */ QGuiApplication_screens() { QList _ret = QGuiApplication::screens(); // Convert QList<> from C++ memory to manually-managed C memory - QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qheaderview.cpp b/qt/gen_qheaderview.cpp index 000619df23..d9f5551e25 100644 --- a/qt/gen_qheaderview.cpp +++ b/qt/gen_qheaderview.cpp @@ -507,12 +507,12 @@ class MiqtVirtualQHeaderView final : public QHeaderView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QHeaderView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -1006,13 +1006,13 @@ class MiqtVirtualQHeaderView final : public QHeaderView { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QHeaderView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QHeaderView_virtualbase_selectedIndexes(const void* self); @@ -2564,13 +2564,13 @@ bool QHeaderView_override_virtual_dataChanged(void* self, intptr_t slot) { } void QHeaderView_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QHeaderView::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QHeaderView::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QHeaderView_override_virtual_rowsInserted(void* self, intptr_t slot) { @@ -2951,12 +2951,12 @@ bool QHeaderView_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QHeaderView_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QHeaderView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qicon.cpp b/qt/gen_qicon.cpp index 18183d6128..05caa21506 100644 --- a/qt/gen_qicon.cpp +++ b/qt/gen_qicon.cpp @@ -126,12 +126,12 @@ void QIcon_addFile(QIcon* self, struct miqt_string fileName) { struct miqt_array /* of QSize* */ QIcon_availableSizes(const QIcon* self) { QList _ret = self->availableSizes(); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -162,8 +162,8 @@ bool QIcon_hasThemeIcon(struct miqt_string name) { struct miqt_array /* of struct miqt_string */ QIcon_themeSearchPaths() { QStringList _ret = QIcon::themeSearchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -174,27 +174,27 @@ struct miqt_array /* of struct miqt_string */ QIcon_themeSearchPaths() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QIcon_setThemeSearchPaths(struct miqt_array /* of struct miqt_string */ searchpath) { - QStringList searchpath_QList; - searchpath_QList.reserve(searchpath.len); + QStringList searchpath_QStringList; + searchpath_QStringList.reserve(searchpath.len); struct miqt_string* searchpath_arr = static_cast(searchpath.data); for(size_t i = 0; i < searchpath.len; ++i) { QString searchpath_arr_i_QString = QString::fromUtf8(searchpath_arr[i].data, searchpath_arr[i].len); - searchpath_QList.push_back(searchpath_arr_i_QString); + searchpath_QStringList.push_back(searchpath_arr_i_QString); } - QIcon::setThemeSearchPaths(searchpath_QList); + QIcon::setThemeSearchPaths(searchpath_QStringList); } struct miqt_array /* of struct miqt_string */ QIcon_fallbackSearchPaths() { QStringList _ret = QIcon::fallbackSearchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -205,20 +205,20 @@ struct miqt_array /* of struct miqt_string */ QIcon_fallbackSearchPaths() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QIcon_setFallbackSearchPaths(struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; - paths_QList.reserve(paths.len); + QStringList paths_QStringList; + paths_QStringList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { QString paths_arr_i_QString = QString::fromUtf8(paths_arr[i].data, paths_arr[i].len); - paths_QList.push_back(paths_arr_i_QString); + paths_QStringList.push_back(paths_arr_i_QString); } - QIcon::setFallbackSearchPaths(paths_QList); + QIcon::setFallbackSearchPaths(paths_QStringList); } struct miqt_string QIcon_themeName() { @@ -351,12 +351,12 @@ void QIcon_addFile4(QIcon* self, struct miqt_string fileName, QSize* size, int m struct miqt_array /* of QSize* */ QIcon_availableSizesWithMode(const QIcon* self, int mode) { QList _ret = self->availableSizes(static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -364,12 +364,12 @@ struct miqt_array /* of QSize* */ QIcon_availableSizesWithMode(const QIcon* sel struct miqt_array /* of QSize* */ QIcon_availableSizes2(const QIcon* self, int mode, int state) { QList _ret = self->availableSizes(static_cast(mode), static_cast(state)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qiconengine.cpp b/qt/gen_qiconengine.cpp index 24d0c42126..e9952117e0 100644 --- a/qt/gen_qiconengine.cpp +++ b/qt/gen_qiconengine.cpp @@ -341,12 +341,12 @@ bool QIconEngine_write(const QIconEngine* self, QDataStream* out) { struct miqt_array /* of QSize* */ QIconEngine_availableSizes(const QIconEngine* self, int mode, int state) { QList _ret = self->availableSizes(static_cast(mode), static_cast(state)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -513,12 +513,12 @@ bool QIconEngine_override_virtual_availableSizes(void* self, intptr_t slot) { struct miqt_array /* of QSize* */ QIconEngine_virtualbase_availableSizes(const void* self, int mode, int state) { QList _ret = static_cast(self)->QIconEngine::availableSizes(static_cast(mode), static_cast(state)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qidentityproxymodel.cpp b/qt/gen_qidentityproxymodel.cpp index b387d738da..0db44ddb44 100644 --- a/qt/gen_qidentityproxymodel.cpp +++ b/qt/gen_qidentityproxymodel.cpp @@ -313,13 +313,13 @@ class MiqtVirtualQIdentityProxyModel final : public QIdentityProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QIdentityProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -759,12 +759,12 @@ class MiqtVirtualQIdentityProxyModel final : public QIdentityProxyModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QIdentityProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -806,14 +806,14 @@ class MiqtVirtualQIdentityProxyModel final : public QIdentityProxyModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QIdentityProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QIdentityProxyModel_virtualbase_mimeTypes(const void* self); @@ -1110,12 +1110,12 @@ QItemSelection* QIdentityProxyModel_mapSelectionToSource(const QIdentityProxyMod struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_match(const QIdentityProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1359,12 +1359,12 @@ bool QIdentityProxyModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QIdentityProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1695,13 +1695,13 @@ bool QIdentityProxyModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QIdentityProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QIdentityProxyModel::mimeData(indexes_QList); + return static_cast(self)->QIdentityProxyModel::mimeData(indexes_QModelIndexList); } bool QIdentityProxyModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -1731,8 +1731,8 @@ bool QIdentityProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QIdentityProxyModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QIdentityProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1743,7 +1743,7 @@ struct miqt_array /* of struct miqt_string */ QIdentityProxyModel_virtualbase_m _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1939,13 +1939,13 @@ void QIdentityProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QIdentityProxyModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2132,19 +2132,19 @@ void QIdentityProxyModel_protectedbase_changePersistentIndexList(bool* _dynamic_ } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2157,12 +2157,12 @@ struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_protectedbase_persi *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qimage.cpp b/qt/gen_qimage.cpp index bef375c1c5..2200ceb638 100644 --- a/qt/gen_qimage.cpp +++ b/qt/gen_qimage.cpp @@ -257,13 +257,13 @@ QImage* QImage_convertToFormat(const QImage* self, int f) { } QImage* QImage_convertToFormat2(const QImage* self, int f, struct miqt_array /* of unsigned int */ colorTable) { - QVector colorTable_QList; - colorTable_QList.reserve(colorTable.len); + QVector colorTable_QVector; + colorTable_QVector.reserve(colorTable.len); unsigned int* colorTable_arr = static_cast(colorTable.data); for(size_t i = 0; i < colorTable.len; ++i) { - colorTable_QList.push_back(static_cast(colorTable_arr[i])); + colorTable_QVector.push_back(static_cast(colorTable_arr[i])); } - return new QImage(self->convertToFormat(static_cast(f), colorTable_QList)); + return new QImage(self->convertToFormat(static_cast(f), colorTable_QVector)); } bool QImage_reinterpretAsFormat(QImage* self, int f) { @@ -419,24 +419,24 @@ void QImage_setPixelColor2(QImage* self, QPoint* pt, QColor* c) { struct miqt_array /* of unsigned int */ QImage_colorTable(const QImage* self) { QVector _ret = self->colorTable(); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QImage_setColorTable(QImage* self, struct miqt_array /* of unsigned int */ colors) { - QVector colors_QList; - colors_QList.reserve(colors.len); + QVector colors_QVector; + colors_QVector.reserve(colors.len); unsigned int* colors_arr = static_cast(colors.data); for(size_t i = 0; i < colors.len; ++i) { - colors_QList.push_back(static_cast(colors_arr[i])); + colors_QVector.push_back(static_cast(colors_arr[i])); } - self->setColorTable(colors_QList); + self->setColorTable(colors_QVector); } double QImage_devicePixelRatio(const QImage* self) { @@ -620,8 +620,8 @@ void QImage_setOffset(QImage* self, QPoint* offset) { struct miqt_array /* of struct miqt_string */ QImage_textKeys(const QImage* self) { QStringList _ret = self->textKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -632,7 +632,7 @@ struct miqt_array /* of struct miqt_string */ QImage_textKeys(const QImage* sel _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -676,13 +676,13 @@ QImage* QImage_convertToFormat3(const QImage* self, int f, int flags) { } QImage* QImage_convertToFormat4(const QImage* self, int f, struct miqt_array /* of unsigned int */ colorTable, int flags) { - QVector colorTable_QList; - colorTable_QList.reserve(colorTable.len); + QVector colorTable_QVector; + colorTable_QVector.reserve(colorTable.len); unsigned int* colorTable_arr = static_cast(colorTable.data); for(size_t i = 0; i < colorTable.len; ++i) { - colorTable_QList.push_back(static_cast(colorTable_arr[i])); + colorTable_QVector.push_back(static_cast(colorTable_arr[i])); } - return new QImage(self->convertToFormat(static_cast(f), colorTable_QList, static_cast(flags))); + return new QImage(self->convertToFormat(static_cast(f), colorTable_QVector, static_cast(flags))); } void QImage_convertTo2(QImage* self, int f, int flags) { diff --git a/qt/gen_qimageiohandler.cpp b/qt/gen_qimageiohandler.cpp index d74f9b771e..4ecdef8b17 100644 --- a/qt/gen_qimageiohandler.cpp +++ b/qt/gen_qimageiohandler.cpp @@ -1,6 +1,4 @@ #include -#include -#include #include #include #include @@ -12,7 +10,6 @@ #include #include #include -#include #include #include #include "gen_qimageiohandler.h" @@ -35,15 +32,6 @@ int miqt_exec_callback_QImageIOHandler_imageCount(const QImageIOHandler*, intptr int miqt_exec_callback_QImageIOHandler_nextImageDelay(const QImageIOHandler*, intptr_t); int miqt_exec_callback_QImageIOHandler_currentImageNumber(const QImageIOHandler*, intptr_t); QRect* miqt_exec_callback_QImageIOHandler_currentImageRect(const QImageIOHandler*, intptr_t); -int miqt_exec_callback_QImageIOPlugin_capabilities(const QImageIOPlugin*, intptr_t, QIODevice*, struct miqt_string); -QImageIOHandler* miqt_exec_callback_QImageIOPlugin_create(const QImageIOPlugin*, intptr_t, QIODevice*, struct miqt_string); -bool miqt_exec_callback_QImageIOPlugin_event(QImageIOPlugin*, intptr_t, QEvent*); -bool miqt_exec_callback_QImageIOPlugin_eventFilter(QImageIOPlugin*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QImageIOPlugin_timerEvent(QImageIOPlugin*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QImageIOPlugin_childEvent(QImageIOPlugin*, intptr_t, QChildEvent*); -void miqt_exec_callback_QImageIOPlugin_customEvent(QImageIOPlugin*, intptr_t, QEvent*); -void miqt_exec_callback_QImageIOPlugin_connectNotify(QImageIOPlugin*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QImageIOPlugin_disconnectNotify(QImageIOPlugin*, intptr_t, QMetaMethod*); #ifdef __cplusplus } /* extern C */ #endif @@ -568,191 +556,6 @@ void QImageIOHandler_delete(QImageIOHandler* self) { delete self; } -class MiqtVirtualQImageIOPlugin final : public QImageIOPlugin { -public: - - MiqtVirtualQImageIOPlugin(): QImageIOPlugin() {} - MiqtVirtualQImageIOPlugin(QObject* parent): QImageIOPlugin(parent) {} - - virtual ~MiqtVirtualQImageIOPlugin() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__capabilities = 0; - - // Subclass to allow providing a Go implementation - virtual QImageIOPlugin::Capabilities capabilities(QIODevice* device, const QByteArray& format) const override { - if (handle__capabilities == 0) { - return QImageIOPlugin::Capabilities(); // Pure virtual, there is no base we can call - } - - QIODevice* sigval1 = device; - const QByteArray format_qb = format; - struct miqt_string format_ms; - format_ms.len = format_qb.length(); - format_ms.data = static_cast(malloc(format_ms.len)); - memcpy(format_ms.data, format_qb.data(), format_ms.len); - struct miqt_string sigval2 = format_ms; - int callback_return_value = miqt_exec_callback_QImageIOPlugin_capabilities(this, handle__capabilities, sigval1, sigval2); - return static_cast(callback_return_value); - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__create = 0; - - // Subclass to allow providing a Go implementation - virtual QImageIOHandler* create(QIODevice* device, const QByteArray& format) const override { - if (handle__create == 0) { - return nullptr; // Pure virtual, there is no base we can call - } - - QIODevice* sigval1 = device; - const QByteArray format_qb = format; - struct miqt_string format_ms; - format_ms.len = format_qb.length(); - format_ms.data = static_cast(malloc(format_ms.len)); - memcpy(format_ms.data, format_qb.data(), format_ms.len); - struct miqt_string sigval2 = format_ms; - QImageIOHandler* callback_return_value = miqt_exec_callback_QImageIOPlugin_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 QImageIOPlugin::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QImageIOPlugin_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QImageIOPlugin_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 QImageIOPlugin::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QImageIOPlugin_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QImageIOPlugin_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) { - QImageIOPlugin::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QImageIOPlugin_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QImageIOPlugin_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QImageIOPlugin_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QImageIOPlugin_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QImageIOPlugin_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QImageIOPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QImageIOPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QImageIOPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QImageIOPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QImageIOPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QImageIOPlugin* QImageIOPlugin_new() { - return new (std::nothrow) MiqtVirtualQImageIOPlugin(); -} - -QImageIOPlugin* QImageIOPlugin_new2(QObject* parent) { - return new (std::nothrow) MiqtVirtualQImageIOPlugin(parent); -} - void QImageIOPlugin_virtbase(QImageIOPlugin* src, QObject** outptr_QObject) { *outptr_QObject = static_cast(src); } @@ -842,168 +645,6 @@ struct miqt_string QImageIOPlugin_trUtf83(const char* s, const char* c, int n) { return _ms; } -bool QImageIOPlugin_override_virtual_capabilities(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__capabilities = slot; - return true; -} - -bool QImageIOPlugin_override_virtual_create(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__create = slot; - return true; -} - -bool QImageIOPlugin_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QImageIOPlugin_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QImageIOPlugin::event(event); -} - -bool QImageIOPlugin_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QImageIOPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QImageIOPlugin::eventFilter(watched, event); -} - -bool QImageIOPlugin_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QImageIOPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QImageIOPlugin::timerEvent(event); -} - -bool QImageIOPlugin_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QImageIOPlugin_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QImageIOPlugin::childEvent(event); -} - -bool QImageIOPlugin_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QImageIOPlugin_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QImageIOPlugin::customEvent(event); -} - -bool QImageIOPlugin_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QImageIOPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QImageIOPlugin::connectNotify(*signal); -} - -bool QImageIOPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QImageIOPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QImageIOPlugin::disconnectNotify(*signal); -} - -QObject* QImageIOPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QImageIOPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QImageIOPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QImageIOPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - void QImageIOPlugin_delete(QImageIOPlugin* self) { delete self; } diff --git a/qt/gen_qimageiohandler.go b/qt/gen_qimageiohandler.go index b2f5f9fe13..3d66befad4 100644 --- a/qt/gen_qimageiohandler.go +++ b/qt/gen_qimageiohandler.go @@ -617,18 +617,6 @@ func UnsafeNewQImageIOPlugin(h unsafe.Pointer) *QImageIOPlugin { return newQImageIOPlugin((*C.QImageIOPlugin)(h)) } -// NewQImageIOPlugin constructs a new QImageIOPlugin object. -func NewQImageIOPlugin() *QImageIOPlugin { - - return newQImageIOPlugin(C.QImageIOPlugin_new()) -} - -// NewQImageIOPlugin2 constructs a new QImageIOPlugin object. -func NewQImageIOPlugin2(parent *QObject) *QImageIOPlugin { - - return newQImageIOPlugin(C.QImageIOPlugin_new2(parent.cPointer())) -} - func (this *QImageIOPlugin) MetaObject() *QMetaObject { return newQMetaObject(C.QImageIOPlugin_metaObject(this.h)) } @@ -723,306 +711,6 @@ func QImageIOPlugin_TrUtf83(s string, c string, n int) string { return _ret } -// Sender can only be called from a QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) Sender() *QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := newQObject(C.QImageIOPlugin_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 QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QImageIOPlugin_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 QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) 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.QImageIOPlugin_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 QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) IsSignalConnected(signal *QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QImageIOPlugin_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 *QImageIOPlugin) OnCapabilities(slot func(device *QIODevice, format []byte) QImageIOPlugin__Capability) { - ok := C.QImageIOPlugin_override_virtual_capabilities(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_QImageIOPlugin_capabilities -func miqt_exec_callback_QImageIOPlugin_capabilities(self *C.QImageIOPlugin, cb C.intptr_t, device *C.QIODevice, format C.struct_miqt_string) C.int { - gofunc, ok := cgo.Handle(cb).Value().(func(device *QIODevice, format []byte) QImageIOPlugin__Capability) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQIODevice(device) - - var format_bytearray C.struct_miqt_string = format - format_ret := C.GoBytes(unsafe.Pointer(format_bytearray.data), C.int(int64(format_bytearray.len))) - C.free(unsafe.Pointer(format_bytearray.data)) - slotval2 := format_ret - - virtualReturn := gofunc(slotval1, slotval2) - - return (C.int)(virtualReturn) - -} -func (this *QImageIOPlugin) OnCreate(slot func(device *QIODevice, format []byte) *QImageIOHandler) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_create -func miqt_exec_callback_QImageIOPlugin_create(self *C.QImageIOPlugin, cb C.intptr_t, device *C.QIODevice, format C.struct_miqt_string) *C.QImageIOHandler { - gofunc, ok := cgo.Handle(cb).Value().(func(device *QIODevice, format []byte) *QImageIOHandler) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQIODevice(device) - - var format_bytearray C.struct_miqt_string = format - format_ret := C.GoBytes(unsafe.Pointer(format_bytearray.data), C.int(int64(format_bytearray.len))) - C.free(unsafe.Pointer(format_bytearray.data)) - slotval2 := format_ret - - virtualReturn := gofunc(slotval1, slotval2) - - return virtualReturn.cPointer() - -} - -func (this *QImageIOPlugin) callVirtualBase_Event(event *QEvent) bool { - - return (bool)(C.QImageIOPlugin_virtualbase_event(unsafe.Pointer(this.h), event.cPointer())) - -} -func (this *QImageIOPlugin) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_event -func miqt_exec_callback_QImageIOPlugin_event(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QImageIOPlugin) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool { - - return (bool)(C.QImageIOPlugin_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer())) - -} -func (this *QImageIOPlugin) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_eventFilter -func miqt_exec_callback_QImageIOPlugin_eventFilter(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QImageIOPlugin) callVirtualBase_TimerEvent(event *QTimerEvent) { - - C.QImageIOPlugin_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer()) - -} -func (this *QImageIOPlugin) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_timerEvent -func miqt_exec_callback_QImageIOPlugin_timerEvent(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_ChildEvent(event *QChildEvent) { - - C.QImageIOPlugin_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer()) - -} -func (this *QImageIOPlugin) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_childEvent -func miqt_exec_callback_QImageIOPlugin_childEvent(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_CustomEvent(event *QEvent) { - - C.QImageIOPlugin_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer()) - -} -func (this *QImageIOPlugin) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_customEvent -func miqt_exec_callback_QImageIOPlugin_customEvent(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_ConnectNotify(signal *QMetaMethod) { - - C.QImageIOPlugin_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer()) - -} -func (this *QImageIOPlugin) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_connectNotify -func miqt_exec_callback_QImageIOPlugin_connectNotify(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_DisconnectNotify(signal *QMetaMethod) { - - C.QImageIOPlugin_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer()) - -} -func (this *QImageIOPlugin) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_disconnectNotify -func miqt_exec_callback_QImageIOPlugin_disconnectNotify(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - // Delete this object from C++ memory. func (this *QImageIOPlugin) Delete() { C.QImageIOPlugin_delete(this.h) diff --git a/qt/gen_qimageiohandler.h b/qt/gen_qimageiohandler.h index dec57708d3..52b94252e8 100644 --- a/qt/gen_qimageiohandler.h +++ b/qt/gen_qimageiohandler.h @@ -15,8 +15,6 @@ extern "C" { #endif #ifdef __cplusplus -class QChildEvent; -class QEvent; class QIODevice; class QImage; class QImageIOHandler; @@ -25,11 +23,8 @@ class QMetaMethod; class QMetaObject; class QObject; class QRect; -class QTimerEvent; class QVariant; #else -typedef struct QChildEvent QChildEvent; -typedef struct QEvent QEvent; typedef struct QIODevice QIODevice; typedef struct QImage QImage; typedef struct QImageIOHandler QImageIOHandler; @@ -38,7 +33,6 @@ typedef struct QMetaMethod QMetaMethod; typedef struct QMetaObject QMetaObject; typedef struct QObject QObject; typedef struct QRect QRect; -typedef struct QTimerEvent QTimerEvent; typedef struct QVariant QVariant; #endif @@ -94,8 +88,6 @@ QRect* QImageIOHandler_virtualbase_currentImageRect(const void* self); void QImageIOHandler_delete(QImageIOHandler* self); -QImageIOPlugin* QImageIOPlugin_new(); -QImageIOPlugin* QImageIOPlugin_new2(QObject* parent); void QImageIOPlugin_virtbase(QImageIOPlugin* src, QObject** outptr_QObject); QMetaObject* QImageIOPlugin_metaObject(const QImageIOPlugin* self); void* QImageIOPlugin_metacast(QImageIOPlugin* self, const char* param1); @@ -108,30 +100,6 @@ struct miqt_string QImageIOPlugin_tr3(const char* s, const char* c, int n); struct miqt_string QImageIOPlugin_trUtf82(const char* s, const char* c); struct miqt_string QImageIOPlugin_trUtf83(const char* s, const char* c, int n); -bool QImageIOPlugin_override_virtual_capabilities(void* self, intptr_t slot); -int QImageIOPlugin_virtualbase_capabilities(const void* self, QIODevice* device, struct miqt_string format); -bool QImageIOPlugin_override_virtual_create(void* self, intptr_t slot); -QImageIOHandler* QImageIOPlugin_virtualbase_create(const void* self, QIODevice* device, struct miqt_string format); -bool QImageIOPlugin_override_virtual_event(void* self, intptr_t slot); -bool QImageIOPlugin_virtualbase_event(void* self, QEvent* event); -bool QImageIOPlugin_override_virtual_eventFilter(void* self, intptr_t slot); -bool QImageIOPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QImageIOPlugin_override_virtual_timerEvent(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QImageIOPlugin_override_virtual_childEvent(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_childEvent(void* self, QChildEvent* event); -bool QImageIOPlugin_override_virtual_customEvent(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_customEvent(void* self, QEvent* event); -bool QImageIOPlugin_override_virtual_connectNotify(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QImageIOPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QImageIOPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QImageIOPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QImageIOPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QImageIOPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - void QImageIOPlugin_delete(QImageIOPlugin* self); #ifdef __cplusplus diff --git a/qt/gen_qimagereader.cpp b/qt/gen_qimagereader.cpp index 1d8bbb1625..e11c5a8bea 100644 --- a/qt/gen_qimagereader.cpp +++ b/qt/gen_qimagereader.cpp @@ -132,8 +132,8 @@ int QImageReader_imageFormat(const QImageReader* self) { struct miqt_array /* of struct miqt_string */ QImageReader_textKeys(const QImageReader* self) { QStringList _ret = self->textKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -144,7 +144,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_textKeys(const QImag _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -238,8 +238,8 @@ struct miqt_string QImageReader_subType(const QImageReader* self) { struct miqt_array /* of struct miqt_string */ QImageReader_supportedSubTypes(const QImageReader* self) { QList _ret = self->supportedSubTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -248,7 +248,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedSubTypes(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -335,8 +335,8 @@ struct miqt_string QImageReader_imageFormatWithDevice(QIODevice* device) { struct miqt_array /* of struct miqt_string */ QImageReader_supportedImageFormats() { QList _ret = QImageReader::supportedImageFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -345,7 +345,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedImageFormat _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -353,8 +353,8 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedImageFormat struct miqt_array /* of struct miqt_string */ QImageReader_supportedMimeTypes() { QList _ret = QImageReader::supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -363,7 +363,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedMimeTypes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -372,8 +372,8 @@ struct miqt_array /* of struct miqt_string */ QImageReader_imageFormatsForMimeT QByteArray mimeType_QByteArray(mimeType.data, mimeType.len); QList _ret = QImageReader::imageFormatsForMimeType(mimeType_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -382,7 +382,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_imageFormatsForMimeT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qimagewriter.cpp b/qt/gen_qimagewriter.cpp index c4d21c7209..a85ca29518 100644 --- a/qt/gen_qimagewriter.cpp +++ b/qt/gen_qimagewriter.cpp @@ -138,8 +138,8 @@ struct miqt_string QImageWriter_subType(const QImageWriter* self) { struct miqt_array /* of struct miqt_string */ QImageWriter_supportedSubTypes(const QImageWriter* self) { QList _ret = self->supportedSubTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -148,7 +148,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedSubTypes(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -231,8 +231,8 @@ bool QImageWriter_supportsOption(const QImageWriter* self, int option) { struct miqt_array /* of struct miqt_string */ QImageWriter_supportedImageFormats() { QList _ret = QImageWriter::supportedImageFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -241,7 +241,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedImageFormat _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -249,8 +249,8 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedImageFormat struct miqt_array /* of struct miqt_string */ QImageWriter_supportedMimeTypes() { QList _ret = QImageWriter::supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -259,7 +259,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedMimeTypes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -268,8 +268,8 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_imageFormatsForMimeT QByteArray mimeType_QByteArray(mimeType.data, mimeType.len); QList _ret = QImageWriter::imageFormatsForMimeType(mimeType_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -278,7 +278,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_imageFormatsForMimeT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qinputdialog.cpp b/qt/gen_qinputdialog.cpp index edab2e48f9..0777bf302b 100644 --- a/qt/gen_qinputdialog.cpp +++ b/qt/gen_qinputdialog.cpp @@ -1122,21 +1122,21 @@ bool QInputDialog_isComboBoxEditable(const QInputDialog* self) { } void QInputDialog_setComboBoxItems(QInputDialog* self, struct miqt_array /* of struct miqt_string */ items) { - QStringList items_QList; - items_QList.reserve(items.len); + QStringList items_QStringList; + items_QStringList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { QString items_arr_i_QString = QString::fromUtf8(items_arr[i].data, items_arr[i].len); - items_QList.push_back(items_arr_i_QString); + items_QStringList.push_back(items_arr_i_QString); } - self->setComboBoxItems(items_QList); + self->setComboBoxItems(items_QStringList); } struct miqt_array /* of struct miqt_string */ QInputDialog_comboBoxItems(const QInputDialog* self) { QStringList _ret = self->comboBoxItems(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1147,7 +1147,7 @@ struct miqt_array /* of struct miqt_string */ QInputDialog_comboBoxItems(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1297,14 +1297,14 @@ struct miqt_string QInputDialog_getMultiLineText(QWidget* parent, struct miqt_st struct miqt_string QInputDialog_getItem(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; - items_QList.reserve(items.len); + QStringList items_QStringList; + items_QStringList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { QString items_arr_i_QString = QString::fromUtf8(items_arr[i].data, items_arr[i].len); - items_QList.push_back(items_arr_i_QString); + items_QStringList.push_back(items_arr_i_QString); } - QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QList); + QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QStringList); // 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; @@ -1602,14 +1602,14 @@ struct miqt_string QInputDialog_getMultiLineText5(QWidget* parent, struct miqt_s struct miqt_string QInputDialog_getItem2(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; - items_QList.reserve(items.len); + QStringList items_QStringList; + items_QStringList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { QString items_arr_i_QString = QString::fromUtf8(items_arr[i].data, items_arr[i].len); - items_QList.push_back(items_arr_i_QString); + items_QStringList.push_back(items_arr_i_QString); } - QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QList, static_cast(current)); + QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QStringList, static_cast(current)); // 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; @@ -1622,14 +1622,14 @@ struct miqt_string QInputDialog_getItem2(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem3(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; - items_QList.reserve(items.len); + QStringList items_QStringList; + items_QStringList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { QString items_arr_i_QString = QString::fromUtf8(items_arr[i].data, items_arr[i].len); - items_QList.push_back(items_arr_i_QString); + items_QStringList.push_back(items_arr_i_QString); } - QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QList, static_cast(current), editable); + QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QStringList, static_cast(current), editable); // 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; @@ -1642,14 +1642,14 @@ struct miqt_string QInputDialog_getItem3(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem4(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable, bool* ok) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; - items_QList.reserve(items.len); + QStringList items_QStringList; + items_QStringList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { QString items_arr_i_QString = QString::fromUtf8(items_arr[i].data, items_arr[i].len); - items_QList.push_back(items_arr_i_QString); + items_QStringList.push_back(items_arr_i_QString); } - QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QList, static_cast(current), editable, ok); + QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QStringList, static_cast(current), editable, ok); // 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; @@ -1662,14 +1662,14 @@ struct miqt_string QInputDialog_getItem4(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem5(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable, bool* ok, int flags) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; - items_QList.reserve(items.len); + QStringList items_QStringList; + items_QStringList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { QString items_arr_i_QString = QString::fromUtf8(items_arr[i].data, items_arr[i].len); - items_QList.push_back(items_arr_i_QString); + items_QStringList.push_back(items_arr_i_QString); } - QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QList, static_cast(current), editable, ok, static_cast(flags)); + QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QStringList, static_cast(current), editable, ok, static_cast(flags)); // 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; @@ -1682,14 +1682,14 @@ struct miqt_string QInputDialog_getItem5(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem6(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable, bool* ok, int flags, int inputMethodHints) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; - items_QList.reserve(items.len); + QStringList items_QStringList; + items_QStringList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { QString items_arr_i_QString = QString::fromUtf8(items_arr[i].data, items_arr[i].len); - items_QList.push_back(items_arr_i_QString); + items_QStringList.push_back(items_arr_i_QString); } - QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QList, static_cast(current), editable, ok, static_cast(flags), static_cast(inputMethodHints)); + QString _ret = QInputDialog::getItem(parent, title_QString, label_QString, items_QStringList, static_cast(current), editable, ok, static_cast(flags), static_cast(inputMethodHints)); // 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; diff --git a/qt/gen_qitemdelegate.cpp b/qt/gen_qitemdelegate.cpp index 46199b412f..6c2e54d302 100644 --- a/qt/gen_qitemdelegate.cpp +++ b/qt/gen_qitemdelegate.cpp @@ -392,13 +392,13 @@ class MiqtVirtualQItemDelegate final : public QItemDelegate { } struct miqt_array /* of int */ callback_return_value = miqt_exec_callback_QItemDelegate_paintingRoles(this, handle__paintingRoles); - QVector callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QVector callback_return_value_QVector; + callback_return_value_QVector.reserve(callback_return_value.len); int* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(static_cast(callback_return_value_arr[i])); + callback_return_value_QVector.push_back(static_cast(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QVector; } friend struct miqt_array /* of int */ QItemDelegate_virtualbase_paintingRoles(const void* self); @@ -859,12 +859,12 @@ bool QItemDelegate_override_virtual_paintingRoles(void* self, intptr_t slot) { struct miqt_array /* of int */ QItemDelegate_virtualbase_paintingRoles(const void* self) { QVector _ret = static_cast(self)->QItemDelegate::paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qitemselectionmodel.cpp b/qt/gen_qitemselectionmodel.cpp index 30638a999f..61b2dee771 100644 --- a/qt/gen_qitemselectionmodel.cpp +++ b/qt/gen_qitemselectionmodel.cpp @@ -150,12 +150,12 @@ bool QItemSelectionRange_isEmpty(const QItemSelectionRange* self) { struct miqt_array /* of QModelIndex* */ QItemSelectionRange_indexes(const QItemSelectionRange* self) { QModelIndexList _ret = self->indexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -491,12 +491,12 @@ bool QItemSelectionModel_hasSelection(const QItemSelectionModel* self) { struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedIndexes(const QItemSelectionModel* self) { QModelIndexList _ret = self->selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -504,12 +504,12 @@ struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedIndexes(con struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedRows(const QItemSelectionModel* self) { QModelIndexList _ret = self->selectedRows(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -517,12 +517,12 @@ struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedRows(const struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedColumns(const QItemSelectionModel* self) { QModelIndexList _ret = self->selectedColumns(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -709,12 +709,12 @@ bool QItemSelectionModel_columnIntersectsSelection2(const QItemSelectionModel* s struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedRowsWithColumn(const QItemSelectionModel* self, int column) { QModelIndexList _ret = self->selectedRows(static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -722,12 +722,12 @@ struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedRowsWithCol struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedColumnsWithRow(const QItemSelectionModel* self, int row) { QModelIndexList _ret = self->selectedColumns(static_cast(row)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -992,12 +992,12 @@ bool QItemSelection_contains(const QItemSelection* self, QModelIndex* index) { struct miqt_array /* of QModelIndex* */ QItemSelection_indexes(const QItemSelection* self) { QModelIndexList _ret = self->indexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qjsonarray.cpp b/qt/gen_qjsonarray.cpp index eba210644b..cdf91df524 100644 --- a/qt/gen_qjsonarray.cpp +++ b/qt/gen_qjsonarray.cpp @@ -34,35 +34,35 @@ void QJsonArray_operatorAssign(QJsonArray* self, QJsonArray* other) { } QJsonArray* QJsonArray_fromStringList(struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; - list_QList.reserve(list.len); + QStringList list_QStringList; + list_QStringList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { QString list_arr_i_QString = QString::fromUtf8(list_arr[i].data, list_arr[i].len); - list_QList.push_back(list_arr_i_QString); + list_QStringList.push_back(list_arr_i_QString); } - return new QJsonArray(QJsonArray::fromStringList(list_QList)); + return new QJsonArray(QJsonArray::fromStringList(list_QStringList)); } QJsonArray* QJsonArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { - QVariantList list_QList; - list_QList.reserve(list.len); + QVariantList list_QVariantList; + list_QVariantList.reserve(list.len); QVariant** list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { - list_QList.push_back(*(list_arr[i])); + list_QVariantList.push_back(*(list_arr[i])); } - return new QJsonArray(QJsonArray::fromVariantList(list_QList)); + return new QJsonArray(QJsonArray::fromVariantList(list_QVariantList)); } struct miqt_array /* of QVariant* */ QJsonArray_toVariantList(const QJsonArray* self) { QVariantList _ret = self->toVariantList(); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qjsonobject.cpp b/qt/gen_qjsonobject.cpp index cee6067354..c9dd91567a 100644 --- a/qt/gen_qjsonobject.cpp +++ b/qt/gen_qjsonobject.cpp @@ -115,8 +115,8 @@ struct miqt_map /* of struct miqt_string to QVariant* */ QJsonObject_toVariantH struct miqt_array /* of struct miqt_string */ QJsonObject_keys(const QJsonObject* self) { QStringList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -127,7 +127,7 @@ struct miqt_array /* of struct miqt_string */ QJsonObject_keys(const QJsonObjec _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qkeysequence.cpp b/qt/gen_qkeysequence.cpp index 779039fbb9..5b389f461e 100644 --- a/qt/gen_qkeysequence.cpp +++ b/qt/gen_qkeysequence.cpp @@ -81,12 +81,12 @@ struct miqt_array /* of QKeySequence* */ QKeySequence_listFromString(struct miq QString str_QString = QString::fromUtf8(str.data, str.len); QList _ret = QKeySequence::listFromString(str_QString); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -121,12 +121,12 @@ QKeySequence* QKeySequence_mnemonic(struct miqt_string text) { struct miqt_array /* of QKeySequence* */ QKeySequence_keyBindings(int key) { QList _ret = QKeySequence::keyBindings(static_cast(key)); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -195,12 +195,12 @@ struct miqt_array /* of QKeySequence* */ QKeySequence_listFromString2(struct mi QString str_QString = QString::fromUtf8(str.data, str.len); QList _ret = QKeySequence::listFromString(str_QString, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qlibraryinfo.cpp b/qt/gen_qlibraryinfo.cpp index f0beb3da20..d5883604b6 100644 --- a/qt/gen_qlibraryinfo.cpp +++ b/qt/gen_qlibraryinfo.cpp @@ -69,8 +69,8 @@ struct miqt_array /* of struct miqt_string */ QLibraryInfo_platformPluginArgume QString platformName_QString = QString::fromUtf8(platformName.data, platformName.len); QStringList _ret = QLibraryInfo::platformPluginArguments(platformName_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -81,7 +81,7 @@ struct miqt_array /* of struct miqt_string */ QLibraryInfo_platformPluginArgume _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qlistview.cpp b/qt/gen_qlistview.cpp index f07207bf92..f71fd3b1e9 100644 --- a/qt/gen_qlistview.cpp +++ b/qt/gen_qlistview.cpp @@ -317,12 +317,12 @@ class MiqtVirtualQListView final : public QListView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QListView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -657,13 +657,13 @@ class MiqtVirtualQListView final : public QListView { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QListView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QListView_virtualbase_selectedIndexes(const void* self); @@ -1949,25 +1949,25 @@ void QListView_setRootIndex(QListView* self, QModelIndex* index) { } void QListView_indexesMoved(QListView* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self->indexesMoved(indexes_QList); + self->indexesMoved(indexes_QModelIndexList); } void QListView_connect_indexesMoved(QListView* self, intptr_t slot) { QListView::connect(self, static_cast(&QListView::indexesMoved), self, [=](const QModelIndexList& indexes) { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; miqt_exec_callback_QListView_indexesMoved(slot, sigval1); @@ -2141,13 +2141,13 @@ bool QListView_override_virtual_dataChanged(void* self, intptr_t slot) { } void QListView_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QListView::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QListView::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QListView_override_virtual_rowsInserted(void* self, intptr_t slot) { @@ -2415,12 +2415,12 @@ bool QListView_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QListView_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QListView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qlistwidget.cpp b/qt/gen_qlistwidget.cpp index a9debdf794..7d829b8480 100644 --- a/qt/gen_qlistwidget.cpp +++ b/qt/gen_qlistwidget.cpp @@ -733,14 +733,14 @@ class MiqtVirtualQListWidget final : public QListWidget { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QListWidget_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QListWidget_virtualbase_mimeTypes(const void* self); @@ -756,12 +756,12 @@ class MiqtVirtualQListWidget final : public QListWidget { const QList items_ret = items; // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** items_arr = static_cast(malloc(sizeof(QListWidgetItem*) * items_ret.length())); - for (size_t i = 0, e = items_ret.length(); i < e; ++i) { + QListWidgetItem** items_arr = static_cast(malloc(sizeof(QListWidgetItem*) * items_ret.size())); + for (size_t i = 0, e = items_ret.size(); i < e; ++i) { items_arr[i] = items_ret[i]; } struct miqt_array items_out; - items_out.len = items_ret.length(); + items_out.len = items_ret.size(); items_out.data = static_cast(items_arr); struct miqt_array /* of QListWidgetItem* */ sigval1 = items_out; QMimeData* callback_return_value = miqt_exec_callback_QListWidget_mimeData(this, handle__mimeData, sigval1); @@ -948,12 +948,12 @@ class MiqtVirtualQListWidget final : public QListWidget { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QListWidget_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -1271,13 +1271,13 @@ class MiqtVirtualQListWidget final : public QListWidget { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QListWidget_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QListWidget_virtualbase_selectedIndexes(const void* self); @@ -2400,14 +2400,14 @@ void QListWidget_insertItem2(QListWidget* self, int row, struct miqt_string labe } void QListWidget_insertItems(QListWidget* self, int row, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; - labels_QList.reserve(labels.len); + QStringList labels_QStringList; + labels_QStringList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { QString labels_arr_i_QString = QString::fromUtf8(labels_arr[i].data, labels_arr[i].len); - labels_QList.push_back(labels_arr_i_QString); + labels_QStringList.push_back(labels_arr_i_QString); } - self->insertItems(static_cast(row), labels_QList); + self->insertItems(static_cast(row), labels_QStringList); } void QListWidget_addItem(QListWidget* self, struct miqt_string label) { @@ -2420,14 +2420,14 @@ void QListWidget_addItemWithItem(QListWidget* self, QListWidgetItem* item) { } void QListWidget_addItems(QListWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; - labels_QList.reserve(labels.len); + QStringList labels_QStringList; + labels_QStringList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { QString labels_arr_i_QString = QString::fromUtf8(labels_arr[i].data, labels_arr[i].len); - labels_QList.push_back(labels_arr_i_QString); + labels_QStringList.push_back(labels_arr_i_QString); } - self->addItems(labels_QList); + self->addItems(labels_QStringList); } QListWidgetItem* QListWidget_takeItem(QListWidget* self, int row) { @@ -2525,12 +2525,12 @@ void QListWidget_setItemSelected(QListWidget* self, QListWidgetItem* item, bool struct miqt_array /* of QListWidgetItem* */ QListWidget_selectedItems(const QListWidget* self) { QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2539,12 +2539,12 @@ struct miqt_array /* of QListWidgetItem* */ QListWidget_findItems(const QListWi QString text_QString = QString::fromUtf8(text.data, text.len); QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2794,8 +2794,8 @@ bool QListWidget_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QListWidget_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QListWidget::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2806,7 +2806,7 @@ struct miqt_array /* of struct miqt_string */ QListWidget_virtualbase_mimeTypes _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2969,13 +2969,13 @@ bool QListWidget_override_virtual_dataChanged(void* self, intptr_t slot) { } void QListWidget_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QListWidget::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QListWidget::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QListWidget_override_virtual_rowsInserted(void* self, intptr_t slot) { @@ -3229,12 +3229,12 @@ bool QListWidget_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QListWidget_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QListWidget::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -4078,12 +4078,12 @@ struct miqt_array /* of QListWidgetItem* */ QListWidget_protectedbase_items(boo *_dynamic_cast_ok = true; QList _ret = self_cast->items(data); // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qlocale.cpp b/qt/gen_qlocale.cpp index fa99b28d21..f04b257b95 100644 --- a/qt/gen_qlocale.cpp +++ b/qt/gen_qlocale.cpp @@ -546,13 +546,13 @@ int QLocale_firstDayOfWeek(const QLocale* self) { struct miqt_array /* of int */ QLocale_weekdays(const QLocale* self) { QList _ret = self->weekdays(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { Qt::DayOfWeek _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -765,8 +765,8 @@ struct miqt_string QLocale_formattedDataSizeWithBytes(const QLocale* self, long struct miqt_array /* of struct miqt_string */ QLocale_uiLanguages(const QLocale* self) { QStringList _ret = self->uiLanguages(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -777,7 +777,7 @@ struct miqt_array /* of struct miqt_string */ QLocale_uiLanguages(const QLocale _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -838,12 +838,12 @@ QLocale* QLocale_system() { struct miqt_array /* of QLocale* */ QLocale_matchingLocales(int language, int script, int country) { QList _ret = QLocale::matchingLocales(static_cast(language), static_cast(script), static_cast(country)); // Convert QList<> from C++ memory to manually-managed C memory - QLocale** _arr = static_cast(malloc(sizeof(QLocale*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QLocale** _arr = static_cast(malloc(sizeof(QLocale*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QLocale(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -851,13 +851,13 @@ struct miqt_array /* of QLocale* */ QLocale_matchingLocales(int language, int s struct miqt_array /* of int */ QLocale_countriesForLanguage(int lang) { QList _ret = QLocale::countriesForLanguage(static_cast(lang)); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QLocale::Country _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -884,14 +884,14 @@ struct miqt_string QLocale_quoteString(const QLocale* self, struct miqt_string s } struct miqt_string QLocale_createSeparatedList(const QLocale* self, struct miqt_array /* of struct miqt_string */ strl) { - QStringList strl_QList; - strl_QList.reserve(strl.len); + QStringList strl_QStringList; + strl_QStringList.reserve(strl.len); struct miqt_string* strl_arr = static_cast(strl.data); for(size_t i = 0; i < strl.len; ++i) { QString strl_arr_i_QString = QString::fromUtf8(strl_arr[i].data, strl_arr[i].len); - strl_QList.push_back(strl_arr_i_QString); + strl_QStringList.push_back(strl_arr_i_QString); } - QString _ret = self->createSeparatedList(strl_QList); + QString _ret = self->createSeparatedList(strl_QStringList); // 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; diff --git a/qt/gen_qmainwindow.cpp b/qt/gen_qmainwindow.cpp index b5a323f73b..ab6394fb05 100644 --- a/qt/gen_qmainwindow.cpp +++ b/qt/gen_qmainwindow.cpp @@ -1151,12 +1151,12 @@ void QMainWindow_tabifyDockWidget(QMainWindow* self, QDockWidget* first, QDockWi struct miqt_array /* of QDockWidget* */ QMainWindow_tabifiedDockWidgets(const QMainWindow* self, QDockWidget* dockwidget) { QList _ret = self->tabifiedDockWidgets(dockwidget); // Convert QList<> from C++ memory to manually-managed C memory - QDockWidget** _arr = static_cast(malloc(sizeof(QDockWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDockWidget** _arr = static_cast(malloc(sizeof(QDockWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qmdiarea.cpp b/qt/gen_qmdiarea.cpp index dbaa23e687..3cee2eb463 100644 --- a/qt/gen_qmdiarea.cpp +++ b/qt/gen_qmdiarea.cpp @@ -1048,12 +1048,12 @@ QMdiSubWindow* QMdiArea_activeSubWindow(const QMdiArea* self) { struct miqt_array /* of QMdiSubWindow* */ QMdiArea_subWindowList(const QMdiArea* self) { QList _ret = self->subWindowList(); // Convert QList<> from C++ memory to manually-managed C memory - QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1228,12 +1228,12 @@ struct miqt_string QMdiArea_trUtf83(const char* s, const char* c, int n) { struct miqt_array /* of QMdiSubWindow* */ QMdiArea_subWindowListWithOrder(const QMdiArea* self, int order) { QList _ret = self->subWindowList(static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qmessagebox.cpp b/qt/gen_qmessagebox.cpp index b7c6770271..88d6b3955b 100644 --- a/qt/gen_qmessagebox.cpp +++ b/qt/gen_qmessagebox.cpp @@ -1109,12 +1109,12 @@ void QMessageBox_removeButton(QMessageBox* self, QAbstractButton* button) { struct miqt_array /* of QAbstractButton* */ QMessageBox_buttons(const QMessageBox* self) { QList _ret = self->buttons(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qmetaobject.cpp b/qt/gen_qmetaobject.cpp index b9d53be639..d4ac98476b 100644 --- a/qt/gen_qmetaobject.cpp +++ b/qt/gen_qmetaobject.cpp @@ -69,8 +69,8 @@ void QMetaMethod_getParameterTypes(const QMetaMethod* self, int* types) { struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterTypes(const QMetaMethod* self) { QList _ret = self->parameterTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -79,7 +79,7 @@ struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterTypes(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -87,8 +87,8 @@ struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterTypes(const struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterNames(const QMetaMethod* self) { QList _ret = self->parameterNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -97,7 +97,7 @@ struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterNames(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qmimedata.cpp b/qt/gen_qmimedata.cpp index e0544ccc62..e4ef082a1c 100644 --- a/qt/gen_qmimedata.cpp +++ b/qt/gen_qmimedata.cpp @@ -73,14 +73,14 @@ class MiqtVirtualQMimeData final : public QMimeData { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QMimeData_formats(this, handle__formats); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QMimeData_virtualbase_formats(const void* self); @@ -280,12 +280,12 @@ struct miqt_string QMimeData_trUtf8(const char* s) { struct miqt_array /* of QUrl* */ QMimeData_urls(const QMimeData* self) { QList _ret = self->urls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -397,8 +397,8 @@ bool QMimeData_hasFormat(const QMimeData* self, struct miqt_string mimetype) { struct miqt_array /* of struct miqt_string */ QMimeData_formats(const QMimeData* self) { QStringList _ret = self->formats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -409,7 +409,7 @@ struct miqt_array /* of struct miqt_string */ QMimeData_formats(const QMimeData _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -490,8 +490,8 @@ bool QMimeData_override_virtual_formats(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QMimeData_virtualbase_formats(const void* self) { QStringList _ret = static_cast(self)->QMimeData::formats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -502,7 +502,7 @@ struct miqt_array /* of struct miqt_string */ QMimeData_virtualbase_formats(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qmimedatabase.cpp b/qt/gen_qmimedatabase.cpp index 225158ff1a..076efda49f 100644 --- a/qt/gen_qmimedatabase.cpp +++ b/qt/gen_qmimedatabase.cpp @@ -41,12 +41,12 @@ struct miqt_array /* of QMimeType* */ QMimeDatabase_mimeTypesForFileName(const QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); QList _ret = self->mimeTypesForFileName(fileName_QString); // Convert QList<> from C++ memory to manually-managed C memory - QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMimeType(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -90,12 +90,12 @@ struct miqt_string QMimeDatabase_suffixForFileName(const QMimeDatabase* self, st struct miqt_array /* of QMimeType* */ QMimeDatabase_allMimeTypes(const QMimeDatabase* self) { QList _ret = self->allMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMimeType(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qmimetype.cpp b/qt/gen_qmimetype.cpp index 2da58953b4..e379667f49 100644 --- a/qt/gen_qmimetype.cpp +++ b/qt/gen_qmimetype.cpp @@ -93,8 +93,8 @@ struct miqt_string QMimeType_iconName(const QMimeType* self) { struct miqt_array /* of struct miqt_string */ QMimeType_globPatterns(const QMimeType* self) { QStringList _ret = self->globPatterns(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -105,7 +105,7 @@ struct miqt_array /* of struct miqt_string */ QMimeType_globPatterns(const QMim _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -113,8 +113,8 @@ struct miqt_array /* of struct miqt_string */ QMimeType_globPatterns(const QMim struct miqt_array /* of struct miqt_string */ QMimeType_parentMimeTypes(const QMimeType* self) { QStringList _ret = self->parentMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -125,7 +125,7 @@ struct miqt_array /* of struct miqt_string */ QMimeType_parentMimeTypes(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -133,8 +133,8 @@ struct miqt_array /* of struct miqt_string */ QMimeType_parentMimeTypes(const Q struct miqt_array /* of struct miqt_string */ QMimeType_allAncestors(const QMimeType* self) { QStringList _ret = self->allAncestors(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -145,7 +145,7 @@ struct miqt_array /* of struct miqt_string */ QMimeType_allAncestors(const QMim _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -153,8 +153,8 @@ struct miqt_array /* of struct miqt_string */ QMimeType_allAncestors(const QMim struct miqt_array /* of struct miqt_string */ QMimeType_aliases(const QMimeType* self) { QStringList _ret = self->aliases(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -165,7 +165,7 @@ struct miqt_array /* of struct miqt_string */ QMimeType_aliases(const QMimeType _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -173,8 +173,8 @@ struct miqt_array /* of struct miqt_string */ QMimeType_aliases(const QMimeType struct miqt_array /* of struct miqt_string */ QMimeType_suffixes(const QMimeType* self) { QStringList _ret = self->suffixes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -185,7 +185,7 @@ struct miqt_array /* of struct miqt_string */ QMimeType_suffixes(const QMimeTyp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qmovie.cpp b/qt/gen_qmovie.cpp index 15a0a8ea34..1c0d698bd3 100644 --- a/qt/gen_qmovie.cpp +++ b/qt/gen_qmovie.cpp @@ -260,8 +260,8 @@ struct miqt_string QMovie_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QMovie_supportedFormats() { QList _ret = QMovie::supportedFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -270,7 +270,7 @@ struct miqt_array /* of struct miqt_string */ QMovie_supportedFormats() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qobject.cpp b/qt/gen_qobject.cpp index a8d9eb2c9e..32052697f0 100644 --- a/qt/gen_qobject.cpp +++ b/qt/gen_qobject.cpp @@ -278,12 +278,12 @@ void QObject_killTimer(QObject* self, int id) { struct miqt_array /* of QObject* */ QObject_children(const QObject* self) { const QObjectList& _ret = self->children(); // Convert QList<> from C++ memory to manually-managed C memory - QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -343,8 +343,8 @@ QVariant* QObject_property(const QObject* self, const char* name) { struct miqt_array /* of struct miqt_string */ QObject_dynamicPropertyNames(const QObject* self) { QList _ret = self->dynamicPropertyNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -353,7 +353,7 @@ struct miqt_array /* of struct miqt_string */ QObject_dynamicPropertyNames(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qpainter.cpp b/qt/gen_qpainter.cpp index 72ef518cef..ded9b01c22 100644 --- a/qt/gen_qpainter.cpp +++ b/qt/gen_qpainter.cpp @@ -416,13 +416,13 @@ void QPainter_drawLines(QPainter* self, QLineF* lines, int lineCount) { } void QPainter_drawLinesWithLines(QPainter* self, struct miqt_array /* of QLineF* */ lines) { - QVector lines_QList; - lines_QList.reserve(lines.len); + QVector lines_QVector; + lines_QVector.reserve(lines.len); QLineF** lines_arr = static_cast(lines.data); for(size_t i = 0; i < lines.len; ++i) { - lines_QList.push_back(*(lines_arr[i])); + lines_QVector.push_back(*(lines_arr[i])); } - self->drawLines(lines_QList); + self->drawLines(lines_QVector); } void QPainter_drawLines2(QPainter* self, QPointF* pointPairs, int lineCount) { @@ -430,13 +430,13 @@ void QPainter_drawLines2(QPainter* self, QPointF* pointPairs, int lineCount) { } void QPainter_drawLinesWithPointPairs(QPainter* self, struct miqt_array /* of QPointF* */ pointPairs) { - QVector pointPairs_QList; - pointPairs_QList.reserve(pointPairs.len); + QVector pointPairs_QVector; + pointPairs_QVector.reserve(pointPairs.len); QPointF** pointPairs_arr = static_cast(pointPairs.data); for(size_t i = 0; i < pointPairs.len; ++i) { - pointPairs_QList.push_back(*(pointPairs_arr[i])); + pointPairs_QVector.push_back(*(pointPairs_arr[i])); } - self->drawLines(pointPairs_QList); + self->drawLines(pointPairs_QVector); } void QPainter_drawLines3(QPainter* self, QLine* lines, int lineCount) { @@ -444,13 +444,13 @@ void QPainter_drawLines3(QPainter* self, QLine* lines, int lineCount) { } void QPainter_drawLines4(QPainter* self, struct miqt_array /* of QLine* */ lines) { - QVector lines_QList; - lines_QList.reserve(lines.len); + QVector lines_QVector; + lines_QVector.reserve(lines.len); QLine** lines_arr = static_cast(lines.data); for(size_t i = 0; i < lines.len; ++i) { - lines_QList.push_back(*(lines_arr[i])); + lines_QVector.push_back(*(lines_arr[i])); } - self->drawLines(lines_QList); + self->drawLines(lines_QVector); } void QPainter_drawLines5(QPainter* self, QPoint* pointPairs, int lineCount) { @@ -458,13 +458,13 @@ void QPainter_drawLines5(QPainter* self, QPoint* pointPairs, int lineCount) { } void QPainter_drawLines6(QPainter* self, struct miqt_array /* of QPoint* */ pointPairs) { - QVector pointPairs_QList; - pointPairs_QList.reserve(pointPairs.len); + QVector pointPairs_QVector; + pointPairs_QVector.reserve(pointPairs.len); QPoint** pointPairs_arr = static_cast(pointPairs.data); for(size_t i = 0; i < pointPairs.len; ++i) { - pointPairs_QList.push_back(*(pointPairs_arr[i])); + pointPairs_QVector.push_back(*(pointPairs_arr[i])); } - self->drawLines(pointPairs_QList); + self->drawLines(pointPairs_QVector); } void QPainter_drawRect(QPainter* self, QRectF* rect) { @@ -484,13 +484,13 @@ void QPainter_drawRects(QPainter* self, QRectF* rects, int rectCount) { } void QPainter_drawRectsWithRectangles(QPainter* self, struct miqt_array /* of QRectF* */ rectangles) { - QVector rectangles_QList; - rectangles_QList.reserve(rectangles.len); + QVector rectangles_QVector; + rectangles_QVector.reserve(rectangles.len); QRectF** rectangles_arr = static_cast(rectangles.data); for(size_t i = 0; i < rectangles.len; ++i) { - rectangles_QList.push_back(*(rectangles_arr[i])); + rectangles_QVector.push_back(*(rectangles_arr[i])); } - self->drawRects(rectangles_QList); + self->drawRects(rectangles_QVector); } void QPainter_drawRects2(QPainter* self, QRect* rects, int rectCount) { @@ -498,13 +498,13 @@ void QPainter_drawRects2(QPainter* self, QRect* rects, int rectCount) { } void QPainter_drawRects3(QPainter* self, struct miqt_array /* of QRect* */ rectangles) { - QVector rectangles_QList; - rectangles_QList.reserve(rectangles.len); + QVector rectangles_QVector; + rectangles_QVector.reserve(rectangles.len); QRect** rectangles_arr = static_cast(rectangles.data); for(size_t i = 0; i < rectangles.len; ++i) { - rectangles_QList.push_back(*(rectangles_arr[i])); + rectangles_QVector.push_back(*(rectangles_arr[i])); } - self->drawRects(rectangles_QList); + self->drawRects(rectangles_QVector); } void QPainter_drawEllipse(QPainter* self, QRectF* r) { diff --git a/qt/gen_qpainterpath.cpp b/qt/gen_qpainterpath.cpp index 8f7523993f..a4e68ec5b7 100644 --- a/qt/gen_qpainterpath.cpp +++ b/qt/gen_qpainterpath.cpp @@ -406,24 +406,24 @@ void QPainterPathStroker_setDashPattern(QPainterPathStroker* self, int dashPatte } void QPainterPathStroker_setDashPatternWithDashPattern(QPainterPathStroker* self, struct miqt_array /* of double */ dashPattern) { - QVector dashPattern_QList; - dashPattern_QList.reserve(dashPattern.len); + QVector dashPattern_QVector; + dashPattern_QVector.reserve(dashPattern.len); double* dashPattern_arr = static_cast(dashPattern.data); for(size_t i = 0; i < dashPattern.len; ++i) { - dashPattern_QList.push_back(static_cast(dashPattern_arr[i])); + dashPattern_QVector.push_back(static_cast(dashPattern_arr[i])); } - self->setDashPattern(dashPattern_QList); + self->setDashPattern(dashPattern_QVector); } struct miqt_array /* of double */ QPainterPathStroker_dashPattern(const QPainterPathStroker* self) { QVector _ret = self->dashPattern(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qpen.cpp b/qt/gen_qpen.cpp index f628ff58e4..70135ccca6 100644 --- a/qt/gen_qpen.cpp +++ b/qt/gen_qpen.cpp @@ -66,24 +66,24 @@ void QPen_setStyle(QPen* self, int style) { struct miqt_array /* of double */ QPen_dashPattern(const QPen* self) { QVector _ret = self->dashPattern(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QPen_setDashPattern(QPen* self, struct miqt_array /* of double */ pattern) { - QVector pattern_QList; - pattern_QList.reserve(pattern.len); + QVector pattern_QVector; + pattern_QVector.reserve(pattern.len); double* pattern_arr = static_cast(pattern.data); for(size_t i = 0; i < pattern.len; ++i) { - pattern_QList.push_back(static_cast(pattern_arr[i])); + pattern_QVector.push_back(static_cast(pattern_arr[i])); } - self->setDashPattern(pattern_QList); + self->setDashPattern(pattern_QVector); } double QPen_dashOffset(const QPen* self) { diff --git a/qt/gen_qpicture.cpp b/qt/gen_qpicture.cpp index 93dcdb7806..e46bf48a2a 100644 --- a/qt/gen_qpicture.cpp +++ b/qt/gen_qpicture.cpp @@ -245,8 +245,8 @@ const char* QPicture_pictureFormat(struct miqt_string fileName) { struct miqt_array /* of struct miqt_string */ QPicture_inputFormats() { QList _ret = QPicture::inputFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -255,7 +255,7 @@ struct miqt_array /* of struct miqt_string */ QPicture_inputFormats() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -263,8 +263,8 @@ struct miqt_array /* of struct miqt_string */ QPicture_inputFormats() { struct miqt_array /* of struct miqt_string */ QPicture_outputFormats() { QList _ret = QPicture::outputFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -273,7 +273,7 @@ struct miqt_array /* of struct miqt_string */ QPicture_outputFormats() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -281,8 +281,8 @@ struct miqt_array /* of struct miqt_string */ QPicture_outputFormats() { struct miqt_array /* of struct miqt_string */ QPicture_inputFormatList() { QStringList _ret = QPicture::inputFormatList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -293,7 +293,7 @@ struct miqt_array /* of struct miqt_string */ QPicture_inputFormatList() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -301,8 +301,8 @@ struct miqt_array /* of struct miqt_string */ QPicture_inputFormatList() { struct miqt_array /* of struct miqt_string */ QPicture_outputFormatList() { QStringList _ret = QPicture::outputFormatList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -313,7 +313,7 @@ struct miqt_array /* of struct miqt_string */ QPicture_outputFormatList() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -575,8 +575,8 @@ struct miqt_string QPictureIO_pictureFormatWithQIODevice(QIODevice* param1) { struct miqt_array /* of struct miqt_string */ QPictureIO_inputFormats() { QList _ret = QPictureIO::inputFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -585,7 +585,7 @@ struct miqt_array /* of struct miqt_string */ QPictureIO_inputFormats() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -593,8 +593,8 @@ struct miqt_array /* of struct miqt_string */ QPictureIO_inputFormats() { struct miqt_array /* of struct miqt_string */ QPictureIO_outputFormats() { QList _ret = QPictureIO::outputFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -603,7 +603,7 @@ struct miqt_array /* of struct miqt_string */ QPictureIO_outputFormats() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qplaintextedit.cpp b/qt/gen_qplaintextedit.cpp index 03ea04a2c1..cc52cde23f 100644 --- a/qt/gen_qplaintextedit.cpp +++ b/qt/gen_qplaintextedit.cpp @@ -1426,12 +1426,12 @@ void QPlainTextEdit_setExtraSelections(QPlainTextEdit* self, struct miqt_array / struct miqt_array /* of QTextEdit__ExtraSelection* */ QPlainTextEdit_extraSelections(const QPlainTextEdit* self) { QList _ret = self->extraSelections(); // Convert QList<> from C++ memory to manually-managed C memory - QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextEdit::ExtraSelection(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qpluginloader.cpp b/qt/gen_qpluginloader.cpp index 3878f4cecd..a4b358ae54 100644 --- a/qt/gen_qpluginloader.cpp +++ b/qt/gen_qpluginloader.cpp @@ -232,12 +232,12 @@ QJsonObject* QPluginLoader_metaData(const QPluginLoader* self) { struct miqt_array /* of QObject* */ QPluginLoader_staticInstances() { QObjectList _ret = QPluginLoader::staticInstances(); // Convert QList<> from C++ memory to manually-managed C memory - QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -245,12 +245,12 @@ struct miqt_array /* of QObject* */ QPluginLoader_staticInstances() { struct miqt_array /* of QStaticPlugin* */ QPluginLoader_staticPlugins() { QVector _ret = QPluginLoader::staticPlugins(); // Convert QList<> from C++ memory to manually-managed C memory - QStaticPlugin** _arr = static_cast(malloc(sizeof(QStaticPlugin*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStaticPlugin** _arr = static_cast(malloc(sizeof(QStaticPlugin*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QStaticPlugin(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qprocess.cpp b/qt/gen_qprocess.cpp index ca524db1f5..27ab700281 100644 --- a/qt/gen_qprocess.cpp +++ b/qt/gen_qprocess.cpp @@ -118,8 +118,8 @@ struct miqt_string QProcessEnvironment_value(const QProcessEnvironment* self, st struct miqt_array /* of struct miqt_string */ QProcessEnvironment_toStringList(const QProcessEnvironment* self) { QStringList _ret = self->toStringList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -130,7 +130,7 @@ struct miqt_array /* of struct miqt_string */ QProcessEnvironment_toStringList( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -138,8 +138,8 @@ struct miqt_array /* of struct miqt_string */ QProcessEnvironment_toStringList( struct miqt_array /* of struct miqt_string */ QProcessEnvironment_keys(const QProcessEnvironment* self) { QStringList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -150,7 +150,7 @@ struct miqt_array /* of struct miqt_string */ QProcessEnvironment_keys(const QP _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -636,14 +636,14 @@ struct miqt_string QProcess_trUtf8(const char* s) { void QProcess_start(QProcess* self, struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } - self->start(program_QString, arguments_QList); + self->start(program_QString, arguments_QStringList); } void QProcess_startWithCommand(QProcess* self, struct miqt_string command) { @@ -682,8 +682,8 @@ void QProcess_setProgram(QProcess* self, struct miqt_string program) { struct miqt_array /* of struct miqt_string */ QProcess_arguments(const QProcess* self) { QStringList _ret = self->arguments(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -694,20 +694,20 @@ struct miqt_array /* of struct miqt_string */ QProcess_arguments(const QProcess _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QProcess_setArguments(QProcess* self, struct miqt_array /* of struct miqt_string */ arguments) { - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } - self->setArguments(arguments_QList); + self->setArguments(arguments_QStringList); } int QProcess_readChannelMode(const QProcess* self) { @@ -790,21 +790,21 @@ void QProcess_setWorkingDirectory(QProcess* self, struct miqt_string dir) { } void QProcess_setEnvironment(QProcess* self, struct miqt_array /* of struct miqt_string */ environment) { - QStringList environment_QList; - environment_QList.reserve(environment.len); + QStringList environment_QStringList; + environment_QStringList.reserve(environment.len); struct miqt_string* environment_arr = static_cast(environment.data); for(size_t i = 0; i < environment.len; ++i) { QString environment_arr_i_QString = QString::fromUtf8(environment_arr[i].data, environment_arr[i].len); - environment_QList.push_back(environment_arr_i_QString); + environment_QStringList.push_back(environment_arr_i_QString); } - self->setEnvironment(environment_QList); + self->setEnvironment(environment_QStringList); } struct miqt_array /* of struct miqt_string */ QProcess_environment(const QProcess* self) { QStringList _ret = self->environment(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -815,7 +815,7 @@ struct miqt_array /* of struct miqt_string */ QProcess_environment(const QProce _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -924,14 +924,14 @@ bool QProcess_atEnd(const QProcess* self) { int QProcess_execute(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } - return QProcess::execute(program_QString, arguments_QList); + return QProcess::execute(program_QString, arguments_QStringList); } int QProcess_executeWithCommand(struct miqt_string command) { @@ -941,27 +941,27 @@ int QProcess_executeWithCommand(struct miqt_string command) { bool QProcess_startDetached2(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments, struct miqt_string workingDirectory) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } QString workingDirectory_QString = QString::fromUtf8(workingDirectory.data, workingDirectory.len); - return QProcess::startDetached(program_QString, arguments_QList, workingDirectory_QString); + return QProcess::startDetached(program_QString, arguments_QStringList, workingDirectory_QString); } bool QProcess_startDetached3(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } - return QProcess::startDetached(program_QString, arguments_QList); + return QProcess::startDetached(program_QString, arguments_QStringList); } bool QProcess_startDetachedWithCommand(struct miqt_string command) { @@ -972,8 +972,8 @@ bool QProcess_startDetachedWithCommand(struct miqt_string command) { struct miqt_array /* of struct miqt_string */ QProcess_systemEnvironment() { QStringList _ret = QProcess::systemEnvironment(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -984,7 +984,7 @@ struct miqt_array /* of struct miqt_string */ QProcess_systemEnvironment() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1102,14 +1102,14 @@ struct miqt_string QProcess_trUtf83(const char* s, const char* c, int n) { void QProcess_start3(QProcess* self, struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments, int mode) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } - self->start(program_QString, arguments_QList, static_cast(mode)); + self->start(program_QString, arguments_QStringList, static_cast(mode)); } void QProcess_start4(QProcess* self, struct miqt_string command, int mode) { @@ -1145,15 +1145,15 @@ bool QProcess_waitForFinishedWithMsecs(QProcess* self, int msecs) { bool QProcess_startDetached4(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments, struct miqt_string workingDirectory, long long* pid) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; - arguments_QList.reserve(arguments.len); + QStringList arguments_QStringList; + arguments_QStringList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { QString arguments_arr_i_QString = QString::fromUtf8(arguments_arr[i].data, arguments_arr[i].len); - arguments_QList.push_back(arguments_arr_i_QString); + arguments_QStringList.push_back(arguments_arr_i_QString); } QString workingDirectory_QString = QString::fromUtf8(workingDirectory.data, workingDirectory.len); - return QProcess::startDetached(program_QString, arguments_QList, workingDirectory_QString, static_cast(pid)); + return QProcess::startDetached(program_QString, arguments_QStringList, workingDirectory_QString, static_cast(pid)); } bool QProcess_override_virtual_open(void* self, intptr_t slot) { diff --git a/qt/gen_qrawfont.cpp b/qt/gen_qrawfont.cpp index 523cef038a..964dee0646 100644 --- a/qt/gen_qrawfont.cpp +++ b/qt/gen_qrawfont.cpp @@ -106,50 +106,50 @@ struct miqt_array /* of unsigned int */ QRawFont_glyphIndexesForString(const QR QString text_QString = QString::fromUtf8(text.data, text.len); QVector _ret = self->glyphIndexesForString(text_QString); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QPointF* */ QRawFont_advancesForGlyphIndexes(const QRawFont* self, struct miqt_array /* of unsigned int */ glyphIndexes) { - QVector glyphIndexes_QList; - glyphIndexes_QList.reserve(glyphIndexes.len); + QVector glyphIndexes_QVector; + glyphIndexes_QVector.reserve(glyphIndexes.len); unsigned int* glyphIndexes_arr = static_cast(glyphIndexes.data); for(size_t i = 0; i < glyphIndexes.len; ++i) { - glyphIndexes_QList.push_back(static_cast(glyphIndexes_arr[i])); + glyphIndexes_QVector.push_back(static_cast(glyphIndexes_arr[i])); } - QVector _ret = self->advancesForGlyphIndexes(glyphIndexes_QList); + QVector _ret = self->advancesForGlyphIndexes(glyphIndexes_QVector); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QPointF* */ QRawFont_advancesForGlyphIndexes2(const QRawFont* self, struct miqt_array /* of unsigned int */ glyphIndexes, int layoutFlags) { - QVector glyphIndexes_QList; - glyphIndexes_QList.reserve(glyphIndexes.len); + QVector glyphIndexes_QVector; + glyphIndexes_QVector.reserve(glyphIndexes.len); unsigned int* glyphIndexes_arr = static_cast(glyphIndexes.data); for(size_t i = 0; i < glyphIndexes.len; ++i) { - glyphIndexes_QList.push_back(static_cast(glyphIndexes_arr[i])); + glyphIndexes_QVector.push_back(static_cast(glyphIndexes_arr[i])); } - QVector _ret = self->advancesForGlyphIndexes(glyphIndexes_QList, static_cast(layoutFlags)); + QVector _ret = self->advancesForGlyphIndexes(glyphIndexes_QVector, static_cast(layoutFlags)); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -263,13 +263,13 @@ bool QRawFont_supportsCharacterWithCharacter(const QRawFont* self, QChar* charac struct miqt_array /* of int */ QRawFont_supportedWritingSystems(const QRawFont* self) { QList _ret = self->supportedWritingSystems(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QFontDatabase::WritingSystem _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qregexp.cpp b/qt/gen_qregexp.cpp index f014dbf676..c69ed628bc 100644 --- a/qt/gen_qregexp.cpp +++ b/qt/gen_qregexp.cpp @@ -129,8 +129,8 @@ int QRegExp_captureCount(const QRegExp* self) { struct miqt_array /* of struct miqt_string */ QRegExp_capturedTexts(const QRegExp* self) { QStringList _ret = self->capturedTexts(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -141,7 +141,7 @@ struct miqt_array /* of struct miqt_string */ QRegExp_capturedTexts(const QRegE _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -149,8 +149,8 @@ struct miqt_array /* of struct miqt_string */ QRegExp_capturedTexts(const QRegE struct miqt_array /* of struct miqt_string */ QRegExp_capturedTexts2(QRegExp* self) { QStringList _ret = self->capturedTexts(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -161,7 +161,7 @@ struct miqt_array /* of struct miqt_string */ QRegExp_capturedTexts2(QRegExp* s _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qregion.cpp b/qt/gen_qregion.cpp index 3389069467..6c0c8ae31f 100644 --- a/qt/gen_qregion.cpp +++ b/qt/gen_qregion.cpp @@ -142,12 +142,12 @@ QRect* QRegion_boundingRect(const QRegion* self) { struct miqt_array /* of QRect* */ QRegion_rects(const QRegion* self) { QVector _ret = self->rects(); // Convert QList<> from C++ memory to manually-managed C memory - QRect** _arr = static_cast(malloc(sizeof(QRect*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QRect** _arr = static_cast(malloc(sizeof(QRect*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QRect(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qregularexpression.cpp b/qt/gen_qregularexpression.cpp index 13ce3acc0f..d2875586a5 100644 --- a/qt/gen_qregularexpression.cpp +++ b/qt/gen_qregularexpression.cpp @@ -93,8 +93,8 @@ int QRegularExpression_captureCount(const QRegularExpression* self) { struct miqt_array /* of struct miqt_string */ QRegularExpression_namedCaptureGroups(const QRegularExpression* self) { QStringList _ret = self->namedCaptureGroups(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -105,7 +105,7 @@ struct miqt_array /* of struct miqt_string */ QRegularExpression_namedCaptureGr _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -274,8 +274,8 @@ struct miqt_string QRegularExpressionMatch_capturedWithName(const QRegularExpres struct miqt_array /* of struct miqt_string */ QRegularExpressionMatch_capturedTexts(const QRegularExpressionMatch* self) { QStringList _ret = self->capturedTexts(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -286,7 +286,7 @@ struct miqt_array /* of struct miqt_string */ QRegularExpressionMatch_capturedT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qresource.cpp b/qt/gen_qresource.cpp index c253a66791..90e7f05e4c 100644 --- a/qt/gen_qresource.cpp +++ b/qt/gen_qresource.cpp @@ -111,8 +111,8 @@ void QResource_addSearchPath(struct miqt_string path) { struct miqt_array /* of struct miqt_string */ QResource_searchPaths() { QStringList _ret = QResource::searchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -123,7 +123,7 @@ struct miqt_array /* of struct miqt_string */ QResource_searchPaths() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qscreen.cpp b/qt/gen_qscreen.cpp index 513f67e20e..20589250ef 100644 --- a/qt/gen_qscreen.cpp +++ b/qt/gen_qscreen.cpp @@ -172,12 +172,12 @@ QRect* QScreen_availableGeometry(const QScreen* self) { struct miqt_array /* of QScreen* */ QScreen_virtualSiblings(const QScreen* self) { QList _ret = self->virtualSiblings(); // Convert QList<> from C++ memory to manually-managed C memory - QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qscroller.cpp b/qt/gen_qscroller.cpp index 8c7f68a171..d1e9cc7756 100644 --- a/qt/gen_qscroller.cpp +++ b/qt/gen_qscroller.cpp @@ -85,12 +85,12 @@ void QScroller_ungrabGesture(QObject* target) { struct miqt_array /* of QScroller* */ QScroller_activeScrollers() { QList _ret = QScroller::activeScrollers(); // Convert QList<> from C++ memory to manually-managed C memory - QScroller** _arr = static_cast(malloc(sizeof(QScroller*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QScroller** _arr = static_cast(malloc(sizeof(QScroller*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qsessionmanager.cpp b/qt/gen_qsessionmanager.cpp index 67295a8956..0f2ef97399 100644 --- a/qt/gen_qsessionmanager.cpp +++ b/qt/gen_qsessionmanager.cpp @@ -99,21 +99,21 @@ int QSessionManager_restartHint(const QSessionManager* self) { } void QSessionManager_setRestartCommand(QSessionManager* self, struct miqt_array /* of struct miqt_string */ restartCommand) { - QStringList restartCommand_QList; - restartCommand_QList.reserve(restartCommand.len); + QStringList restartCommand_QStringList; + restartCommand_QStringList.reserve(restartCommand.len); struct miqt_string* restartCommand_arr = static_cast(restartCommand.data); for(size_t i = 0; i < restartCommand.len; ++i) { QString restartCommand_arr_i_QString = QString::fromUtf8(restartCommand_arr[i].data, restartCommand_arr[i].len); - restartCommand_QList.push_back(restartCommand_arr_i_QString); + restartCommand_QStringList.push_back(restartCommand_arr_i_QString); } - self->setRestartCommand(restartCommand_QList); + self->setRestartCommand(restartCommand_QStringList); } struct miqt_array /* of struct miqt_string */ QSessionManager_restartCommand(const QSessionManager* self) { QStringList _ret = self->restartCommand(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -124,27 +124,27 @@ struct miqt_array /* of struct miqt_string */ QSessionManager_restartCommand(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QSessionManager_setDiscardCommand(QSessionManager* self, struct miqt_array /* of struct miqt_string */ discardCommand) { - QStringList discardCommand_QList; - discardCommand_QList.reserve(discardCommand.len); + QStringList discardCommand_QStringList; + discardCommand_QStringList.reserve(discardCommand.len); struct miqt_string* discardCommand_arr = static_cast(discardCommand.data); for(size_t i = 0; i < discardCommand.len; ++i) { QString discardCommand_arr_i_QString = QString::fromUtf8(discardCommand_arr[i].data, discardCommand_arr[i].len); - discardCommand_QList.push_back(discardCommand_arr_i_QString); + discardCommand_QStringList.push_back(discardCommand_arr_i_QString); } - self->setDiscardCommand(discardCommand_QList); + self->setDiscardCommand(discardCommand_QStringList); } struct miqt_array /* of struct miqt_string */ QSessionManager_discardCommand(const QSessionManager* self) { QStringList _ret = self->discardCommand(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -155,7 +155,7 @@ struct miqt_array /* of struct miqt_string */ QSessionManager_discardCommand(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -168,14 +168,14 @@ void QSessionManager_setManagerProperty(QSessionManager* self, struct miqt_strin void QSessionManager_setManagerProperty2(QSessionManager* self, struct miqt_string name, struct miqt_array /* of struct miqt_string */ value) { QString name_QString = QString::fromUtf8(name.data, name.len); - QStringList value_QList; - value_QList.reserve(value.len); + QStringList value_QStringList; + value_QStringList.reserve(value.len); struct miqt_string* value_arr = static_cast(value.data); for(size_t i = 0; i < value.len; ++i) { QString value_arr_i_QString = QString::fromUtf8(value_arr[i].data, value_arr[i].len); - value_QList.push_back(value_arr_i_QString); + value_QStringList.push_back(value_arr_i_QString); } - self->setManagerProperty(name_QString, value_QList); + self->setManagerProperty(name_QString, value_QStringList); } bool QSessionManager_isPhase2(const QSessionManager* self) { diff --git a/qt/gen_qsettings.cpp b/qt/gen_qsettings.cpp index 0d3a2d472e..6e189db390 100644 --- a/qt/gen_qsettings.cpp +++ b/qt/gen_qsettings.cpp @@ -352,8 +352,8 @@ void QSettings_setArrayIndex(QSettings* self, int i) { struct miqt_array /* of struct miqt_string */ QSettings_allKeys(const QSettings* self) { QStringList _ret = self->allKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -364,7 +364,7 @@ struct miqt_array /* of struct miqt_string */ QSettings_allKeys(const QSettings _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -372,8 +372,8 @@ struct miqt_array /* of struct miqt_string */ QSettings_allKeys(const QSettings struct miqt_array /* of struct miqt_string */ QSettings_childKeys(const QSettings* self) { QStringList _ret = self->childKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -384,7 +384,7 @@ struct miqt_array /* of struct miqt_string */ QSettings_childKeys(const QSettin _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -392,8 +392,8 @@ struct miqt_array /* of struct miqt_string */ QSettings_childKeys(const QSettin struct miqt_array /* of struct miqt_string */ QSettings_childGroups(const QSettings* self) { QStringList _ret = self->childGroups(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -404,7 +404,7 @@ struct miqt_array /* of struct miqt_string */ QSettings_childGroups(const QSett _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qsortfilterproxymodel.cpp b/qt/gen_qsortfilterproxymodel.cpp index 3cd9a2e4d3..be98a0c6a9 100644 --- a/qt/gen_qsortfilterproxymodel.cpp +++ b/qt/gen_qsortfilterproxymodel.cpp @@ -450,12 +450,12 @@ class MiqtVirtualQSortFilterProxyModel final : public QSortFilterProxyModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QSortFilterProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -660,13 +660,13 @@ class MiqtVirtualQSortFilterProxyModel final : public QSortFilterProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QSortFilterProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -718,14 +718,14 @@ class MiqtVirtualQSortFilterProxyModel final : public QSortFilterProxyModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QSortFilterProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_virtualbase_mimeTypes(const void* self); @@ -1316,13 +1316,13 @@ bool QSortFilterProxyModel_setHeaderData(QSortFilterProxyModel* self, int sectio } QMimeData* QSortFilterProxyModel_mimeData(const QSortFilterProxyModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return self->mimeData(indexes_QList); + return self->mimeData(indexes_QModelIndexList); } bool QSortFilterProxyModel_dropMimeData(QSortFilterProxyModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { @@ -1365,12 +1365,12 @@ QModelIndex* QSortFilterProxyModel_buddy(const QSortFilterProxyModel* self, QMod struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_match(const QSortFilterProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1386,8 +1386,8 @@ void QSortFilterProxyModel_sort(QSortFilterProxyModel* self, int column, int ord struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_mimeTypes(const QSortFilterProxyModel* self) { QStringList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1398,7 +1398,7 @@ struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_mimeTypes(c _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1794,13 +1794,13 @@ bool QSortFilterProxyModel_override_virtual_mimeData(void* self, intptr_t slot) } QMimeData* QSortFilterProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QSortFilterProxyModel::mimeData(indexes_QList); + return static_cast(self)->QSortFilterProxyModel::mimeData(indexes_QModelIndexList); } bool QSortFilterProxyModel_override_virtual_dropMimeData(void* self, intptr_t slot) { @@ -1943,12 +1943,12 @@ bool QSortFilterProxyModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QSortFilterProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1994,8 +1994,8 @@ bool QSortFilterProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QSortFilterProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2006,7 +2006,7 @@ struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_virtualbase _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2342,13 +2342,13 @@ void QSortFilterProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, cons } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QSortFilterProxyModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2535,19 +2535,19 @@ void QSortFilterProxyModel_protectedbase_changePersistentIndexList(bool* _dynami } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2560,12 +2560,12 @@ struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_protectedbase_per *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qsplitter.cpp b/qt/gen_qsplitter.cpp index d83c4ccb31..6547e0c27d 100644 --- a/qt/gen_qsplitter.cpp +++ b/qt/gen_qsplitter.cpp @@ -1090,12 +1090,12 @@ QSize* QSplitter_minimumSizeHint(const QSplitter* self) { struct miqt_array /* of int */ QSplitter_sizes(const QSplitter* self) { QList _ret = self->sizes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstandarditemmodel.cpp b/qt/gen_qstandarditemmodel.cpp index f13a350b4b..ee9ae46aa1 100644 --- a/qt/gen_qstandarditemmodel.cpp +++ b/qt/gen_qstandarditemmodel.cpp @@ -639,12 +639,12 @@ QStandardItem* QStandardItem_takeChild(QStandardItem* self, int row) { struct miqt_array /* of QStandardItem* */ QStandardItem_takeRow(QStandardItem* self, int row) { QList _ret = self->takeRow(static_cast(row)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -652,12 +652,12 @@ struct miqt_array /* of QStandardItem* */ QStandardItem_takeRow(QStandardItem* struct miqt_array /* of QStandardItem* */ QStandardItem_takeColumn(QStandardItem* self, int column) { QList _ret = self->takeColumn(static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1214,14 +1214,14 @@ class MiqtVirtualQStandardItemModel final : public QStandardItemModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QStandardItemModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QStandardItemModel_virtualbase_mimeTypes(const void* self); @@ -1237,12 +1237,12 @@ class MiqtVirtualQStandardItemModel final : public QStandardItemModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QStandardItemModel_mimeData(this, handle__mimeData, sigval1); @@ -1435,13 +1435,13 @@ class MiqtVirtualQStandardItemModel final : public QStandardItemModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QStandardItemModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QStandardItemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -1877,25 +1877,25 @@ void QStandardItemModel_setVerticalHeaderItem(QStandardItemModel* self, int row, } void QStandardItemModel_setHorizontalHeaderLabels(QStandardItemModel* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; - labels_QList.reserve(labels.len); + QStringList labels_QStringList; + labels_QStringList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { QString labels_arr_i_QString = QString::fromUtf8(labels_arr[i].data, labels_arr[i].len); - labels_QList.push_back(labels_arr_i_QString); + labels_QStringList.push_back(labels_arr_i_QString); } - self->setHorizontalHeaderLabels(labels_QList); + self->setHorizontalHeaderLabels(labels_QStringList); } void QStandardItemModel_setVerticalHeaderLabels(QStandardItemModel* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; - labels_QList.reserve(labels.len); + QStringList labels_QStringList; + labels_QStringList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { QString labels_arr_i_QString = QString::fromUtf8(labels_arr[i].data, labels_arr[i].len); - labels_QList.push_back(labels_arr_i_QString); + labels_QStringList.push_back(labels_arr_i_QString); } - self->setVerticalHeaderLabels(labels_QList); + self->setVerticalHeaderLabels(labels_QStringList); } void QStandardItemModel_setRowCount(QStandardItemModel* self, int rows) { @@ -1969,12 +1969,12 @@ QStandardItem* QStandardItemModel_takeItem(QStandardItemModel* self, int row) { struct miqt_array /* of QStandardItem* */ QStandardItemModel_takeRow(QStandardItemModel* self, int row) { QList _ret = self->takeRow(static_cast(row)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1982,12 +1982,12 @@ struct miqt_array /* of QStandardItem* */ QStandardItemModel_takeRow(QStandardI struct miqt_array /* of QStandardItem* */ QStandardItemModel_takeColumn(QStandardItemModel* self, int column) { QList _ret = self->takeColumn(static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2012,12 +2012,12 @@ struct miqt_array /* of QStandardItem* */ QStandardItemModel_findItems(const QS QString text_QString = QString::fromUtf8(text.data, text.len); QList _ret = self->findItems(text_QString); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2033,8 +2033,8 @@ void QStandardItemModel_setSortRole(QStandardItemModel* self, int role) { struct miqt_array /* of struct miqt_string */ QStandardItemModel_mimeTypes(const QStandardItemModel* self) { QStringList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2045,19 +2045,19 @@ struct miqt_array /* of struct miqt_string */ QStandardItemModel_mimeTypes(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QStandardItemModel_mimeData(const QStandardItemModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return self->mimeData(indexes_QList); + return self->mimeData(indexes_QModelIndexList); } bool QStandardItemModel_dropMimeData(QStandardItemModel* self, QMimeData* data, int action, int row, int column, QModelIndex* parent) { @@ -2139,12 +2139,12 @@ struct miqt_array /* of QStandardItem* */ QStandardItemModel_findItems2(const Q QString text_QString = QString::fromUtf8(text.data, text.len); QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2153,12 +2153,12 @@ struct miqt_array /* of QStandardItem* */ QStandardItemModel_findItems3(const Q QString text_QString = QString::fromUtf8(text.data, text.len); QList _ret = self->findItems(text_QString, static_cast(flags), static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2464,8 +2464,8 @@ bool QStandardItemModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QStandardItemModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QStandardItemModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2476,7 +2476,7 @@ struct miqt_array /* of struct miqt_string */ QStandardItemModel_virtualbase_mi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2492,13 +2492,13 @@ bool QStandardItemModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QStandardItemModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QStandardItemModel::mimeData(indexes_QList); + return static_cast(self)->QStandardItemModel::mimeData(indexes_QModelIndexList); } bool QStandardItemModel_override_virtual_dropMimeData(void* self, intptr_t slot) { @@ -2627,12 +2627,12 @@ bool QStandardItemModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QStandardItemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QStandardItemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2840,13 +2840,13 @@ void QStandardItemModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const v } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QStandardItemModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -3033,19 +3033,19 @@ void QStandardItemModel_protectedbase_changePersistentIndexList(bool* _dynamic_c } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QStandardItemModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -3058,12 +3058,12 @@ struct miqt_array /* of QModelIndex* */ QStandardItemModel_protectedbase_persis *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstandardpaths.cpp b/qt/gen_qstandardpaths.cpp index 1449a28552..c7936a2a21 100644 --- a/qt/gen_qstandardpaths.cpp +++ b/qt/gen_qstandardpaths.cpp @@ -28,8 +28,8 @@ struct miqt_string QStandardPaths_writableLocation(int type) { struct miqt_array /* of struct miqt_string */ QStandardPaths_standardLocations(int type) { QStringList _ret = QStandardPaths::standardLocations(static_cast(type)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -40,7 +40,7 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_standardLocations( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -61,8 +61,8 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll(int type QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); QStringList _ret = QStandardPaths::locateAll(static_cast(type), fileName_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -73,7 +73,7 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll(int type _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -129,8 +129,8 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll2(int typ QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); QStringList _ret = QStandardPaths::locateAll(static_cast(type), fileName_QString, static_cast(options)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -141,21 +141,21 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll2(int typ _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_string QStandardPaths_findExecutable2(struct miqt_string executableName, struct miqt_array /* of struct miqt_string */ paths) { QString executableName_QString = QString::fromUtf8(executableName.data, executableName.len); - QStringList paths_QList; - paths_QList.reserve(paths.len); + QStringList paths_QStringList; + paths_QStringList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { QString paths_arr_i_QString = QString::fromUtf8(paths_arr[i].data, paths_arr[i].len); - paths_QList.push_back(paths_arr_i_QString); + paths_QStringList.push_back(paths_arr_i_QString); } - QString _ret = QStandardPaths::findExecutable(executableName_QString, paths_QList); + QString _ret = QStandardPaths::findExecutable(executableName_QString, paths_QStringList); // 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; diff --git a/qt/gen_qstate.cpp b/qt/gen_qstate.cpp index 4303d33e08..f6b4e08ec3 100644 --- a/qt/gen_qstate.cpp +++ b/qt/gen_qstate.cpp @@ -288,12 +288,12 @@ void QState_removeTransition(QState* self, QAbstractTransition* transition) { struct miqt_array /* of QAbstractTransition* */ QState_transitions(const QState* self) { QList _ret = self->transitions(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractTransition** _arr = static_cast(malloc(sizeof(QAbstractTransition*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractTransition** _arr = static_cast(malloc(sizeof(QAbstractTransition*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstatemachine.cpp b/qt/gen_qstatemachine.cpp index 454522175e..1349a5243a 100644 --- a/qt/gen_qstatemachine.cpp +++ b/qt/gen_qstatemachine.cpp @@ -381,12 +381,12 @@ void QStateMachine_addDefaultAnimation(QStateMachine* self, QAbstractAnimation* struct miqt_array /* of QAbstractAnimation* */ QStateMachine_defaultAnimations(const QStateMachine* self) { QList _ret = self->defaultAnimations(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractAnimation** _arr = static_cast(malloc(sizeof(QAbstractAnimation*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractAnimation** _arr = static_cast(malloc(sizeof(QAbstractAnimation*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -777,12 +777,12 @@ int QStateMachine__SignalEvent_signalIndex(const QStateMachine__SignalEvent* sel struct miqt_array /* of QVariant* */ QStateMachine__SignalEvent_arguments(const QStateMachine__SignalEvent* self) { QList _ret = self->arguments(); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstorageinfo.cpp b/qt/gen_qstorageinfo.cpp index da69a1dde6..f33eec1199 100644 --- a/qt/gen_qstorageinfo.cpp +++ b/qt/gen_qstorageinfo.cpp @@ -148,12 +148,12 @@ void QStorageInfo_refresh(QStorageInfo* self) { struct miqt_array /* of QStorageInfo* */ QStorageInfo_mountedVolumes() { QList _ret = QStorageInfo::mountedVolumes(); // Convert QList<> from C++ memory to manually-managed C memory - QStorageInfo** _arr = static_cast(malloc(sizeof(QStorageInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStorageInfo** _arr = static_cast(malloc(sizeof(QStorageInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QStorageInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstringlistmodel.cpp b/qt/gen_qstringlistmodel.cpp index 978a3c05be..bb2ba01113 100644 --- a/qt/gen_qstringlistmodel.cpp +++ b/qt/gen_qstringlistmodel.cpp @@ -424,14 +424,14 @@ class MiqtVirtualQStringListModel final : public QStringListModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QStringListModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QStringListModel_virtualbase_mimeTypes(const void* self); @@ -447,12 +447,12 @@ class MiqtVirtualQStringListModel final : public QStringListModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QStringListModel_mimeData(this, handle__mimeData, sigval1); @@ -638,13 +638,13 @@ class MiqtVirtualQStringListModel final : public QStringListModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QStringListModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QStringListModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -876,14 +876,14 @@ QStringListModel* QStringListModel_new() { } QStringListModel* QStringListModel_new2(struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQStringListModel(strings_QList); + return new (std::nothrow) MiqtVirtualQStringListModel(strings_QStringList); } QStringListModel* QStringListModel_new3(QObject* parent) { @@ -891,14 +891,14 @@ QStringListModel* QStringListModel_new3(QObject* parent) { } QStringListModel* QStringListModel_new4(struct miqt_array /* of struct miqt_string */ strings, QObject* parent) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQStringListModel(strings_QList, parent); + return new (std::nothrow) MiqtVirtualQStringListModel(strings_QStringList, parent); } void QStringListModel_virtbase(QStringListModel* src, QAbstractListModel** outptr_QAbstractListModel) { @@ -1003,8 +1003,8 @@ void QStringListModel_sort(QStringListModel* self, int column, int order) { struct miqt_array /* of struct miqt_string */ QStringListModel_stringList(const QStringListModel* self) { QStringList _ret = self->stringList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1015,20 +1015,20 @@ struct miqt_array /* of struct miqt_string */ QStringListModel_stringList(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QStringListModel_setStringList(QStringListModel* self, struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - self->setStringList(strings_QList); + self->setStringList(strings_QStringList); } int QStringListModel_supportedDropActions(const QStringListModel* self) { @@ -1339,8 +1339,8 @@ bool QStringListModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QStringListModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QStringListModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1351,7 +1351,7 @@ struct miqt_array /* of struct miqt_string */ QStringListModel_virtualbase_mime _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1367,13 +1367,13 @@ bool QStringListModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QStringListModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QStringListModel::mimeData(indexes_QList); + return static_cast(self)->QStringListModel::mimeData(indexes_QModelIndexList); } bool QStringListModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -1502,12 +1502,12 @@ bool QStringListModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QStringListModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QStringListModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1715,13 +1715,13 @@ void QStringListModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const voi } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QStringListModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -1908,19 +1908,19 @@ void QStringListModel_protectedbase_changePersistentIndexList(bool* _dynamic_cas } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QStringListModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -1933,12 +1933,12 @@ struct miqt_array /* of QModelIndex* */ QStringListModel_protectedbase_persiste *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstringview.cpp b/qt/gen_qstringview.cpp index 30508b9843..3632fdeb25 100644 --- a/qt/gen_qstringview.cpp +++ b/qt/gen_qstringview.cpp @@ -75,12 +75,12 @@ struct miqt_string QStringView_toLocal8Bit(const QStringView* self) { struct miqt_array /* of unsigned int */ QStringView_toUcs4(const QStringView* self) { QVector _ret = self->toUcs4(); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstyleditemdelegate.cpp b/qt/gen_qstyleditemdelegate.cpp index 9c8a0f8e0e..d19a6d0172 100644 --- a/qt/gen_qstyleditemdelegate.cpp +++ b/qt/gen_qstyleditemdelegate.cpp @@ -324,13 +324,13 @@ class MiqtVirtualQStyledItemDelegate final : public QStyledItemDelegate { } struct miqt_array /* of int */ callback_return_value = miqt_exec_callback_QStyledItemDelegate_paintingRoles(this, handle__paintingRoles); - QVector callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QVector callback_return_value_QVector; + callback_return_value_QVector.reserve(callback_return_value.len); int* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(static_cast(callback_return_value_arr[i])); + callback_return_value_QVector.push_back(static_cast(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QVector; } friend struct miqt_array /* of int */ QStyledItemDelegate_virtualbase_paintingRoles(const void* self); @@ -764,12 +764,12 @@ bool QStyledItemDelegate_override_virtual_paintingRoles(void* self, intptr_t slo struct miqt_array /* of int */ QStyledItemDelegate_virtualbase_paintingRoles(const void* self) { QVector _ret = static_cast(self)->QStyledItemDelegate::paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qstylefactory.cpp b/qt/gen_qstylefactory.cpp index 931e0d2c58..3de2eba2ac 100644 --- a/qt/gen_qstylefactory.cpp +++ b/qt/gen_qstylefactory.cpp @@ -18,8 +18,8 @@ extern "C" { struct miqt_array /* of struct miqt_string */ QStyleFactory_keys() { QStringList _ret = QStyleFactory::keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -30,7 +30,7 @@ struct miqt_array /* of struct miqt_string */ QStyleFactory_keys() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtableview.cpp b/qt/gen_qtableview.cpp index db7f1551aa..b45443a9c0 100644 --- a/qt/gen_qtableview.cpp +++ b/qt/gen_qtableview.cpp @@ -448,13 +448,13 @@ class MiqtVirtualQTableView final : public QTableView { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTableView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QTableView_virtualbase_selectedIndexes(const void* self); @@ -709,12 +709,12 @@ class MiqtVirtualQTableView final : public QTableView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTableView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -2274,12 +2274,12 @@ bool QTableView_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QTableView_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QTableView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2478,13 +2478,13 @@ bool QTableView_override_virtual_dataChanged(void* self, intptr_t slot) { } void QTableView_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QTableView::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QTableView::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QTableView_override_virtual_rowsInserted(void* self, intptr_t slot) { diff --git a/qt/gen_qtablewidget.cpp b/qt/gen_qtablewidget.cpp index 2d98b0f357..668492333d 100644 --- a/qt/gen_qtablewidget.cpp +++ b/qt/gen_qtablewidget.cpp @@ -700,14 +700,14 @@ class MiqtVirtualQTableWidget final : public QTableWidget { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QTableWidget_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QTableWidget_virtualbase_mimeTypes(const void* self); @@ -723,12 +723,12 @@ class MiqtVirtualQTableWidget final : public QTableWidget { const QList items_ret = items; // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** items_arr = static_cast(malloc(sizeof(QTableWidgetItem*) * items_ret.length())); - for (size_t i = 0, e = items_ret.length(); i < e; ++i) { + QTableWidgetItem** items_arr = static_cast(malloc(sizeof(QTableWidgetItem*) * items_ret.size())); + for (size_t i = 0, e = items_ret.size(); i < e; ++i) { items_arr[i] = items_ret[i]; } struct miqt_array items_out; - items_out.len = items_ret.length(); + items_out.len = items_ret.size(); items_out.data = static_cast(items_arr); struct miqt_array /* of QTableWidgetItem* */ sigval1 = items_out; QMimeData* callback_return_value = miqt_exec_callback_QTableWidget_mimeData(this, handle__mimeData, sigval1); @@ -1063,13 +1063,13 @@ class MiqtVirtualQTableWidget final : public QTableWidget { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTableWidget_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QTableWidget_virtualbase_selectedIndexes(const void* self); @@ -1324,12 +1324,12 @@ class MiqtVirtualQTableWidget final : public QTableWidget { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTableWidget_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -2451,25 +2451,25 @@ QTableWidgetItem* QTableWidget_takeHorizontalHeaderItem(QTableWidget* self, int } void QTableWidget_setVerticalHeaderLabels(QTableWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; - labels_QList.reserve(labels.len); + QStringList labels_QStringList; + labels_QStringList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { QString labels_arr_i_QString = QString::fromUtf8(labels_arr[i].data, labels_arr[i].len); - labels_QList.push_back(labels_arr_i_QString); + labels_QStringList.push_back(labels_arr_i_QString); } - self->setVerticalHeaderLabels(labels_QList); + self->setVerticalHeaderLabels(labels_QStringList); } void QTableWidget_setHorizontalHeaderLabels(QTableWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; - labels_QList.reserve(labels.len); + QStringList labels_QStringList; + labels_QStringList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { QString labels_arr_i_QString = QString::fromUtf8(labels_arr[i].data, labels_arr[i].len); - labels_QList.push_back(labels_arr_i_QString); + labels_QStringList.push_back(labels_arr_i_QString); } - self->setHorizontalHeaderLabels(labels_QList); + self->setHorizontalHeaderLabels(labels_QStringList); } int QTableWidget_currentRow(const QTableWidget* self) { @@ -2555,12 +2555,12 @@ void QTableWidget_setRangeSelected(QTableWidget* self, QTableWidgetSelectionRang struct miqt_array /* of QTableWidgetSelectionRange* */ QTableWidget_selectedRanges(const QTableWidget* self) { QList _ret = self->selectedRanges(); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetSelectionRange** _arr = static_cast(malloc(sizeof(QTableWidgetSelectionRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetSelectionRange** _arr = static_cast(malloc(sizeof(QTableWidgetSelectionRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTableWidgetSelectionRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2568,12 +2568,12 @@ struct miqt_array /* of QTableWidgetSelectionRange* */ QTableWidget_selectedRan struct miqt_array /* of QTableWidgetItem* */ QTableWidget_selectedItems(const QTableWidget* self) { QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2582,12 +2582,12 @@ struct miqt_array /* of QTableWidgetItem* */ QTableWidget_findItems(const QTabl QString text_QString = QString::fromUtf8(text.data, text.len); QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2901,8 +2901,8 @@ bool QTableWidget_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QTableWidget_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QTableWidget::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2913,7 +2913,7 @@ struct miqt_array /* of struct miqt_string */ QTableWidget_virtualbase_mimeType _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3204,12 +3204,12 @@ bool QTableWidget_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QTableWidget_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QTableWidget::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3408,13 +3408,13 @@ bool QTableWidget_override_virtual_dataChanged(void* self, intptr_t slot) { } void QTableWidget_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QTableWidget::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QTableWidget::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QTableWidget_override_virtual_rowsInserted(void* self, intptr_t slot) { @@ -4213,12 +4213,12 @@ struct miqt_array /* of QTableWidgetItem* */ QTableWidget_protectedbase_items(b *_dynamic_cast_ok = true; QList _ret = self_cast->items(data); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextbrowser.cpp b/qt/gen_qtextbrowser.cpp index 067a6693de..29266baa27 100644 --- a/qt/gen_qtextbrowser.cpp +++ b/qt/gen_qtextbrowser.cpp @@ -1231,8 +1231,8 @@ int QTextBrowser_sourceType(const QTextBrowser* self) { struct miqt_array /* of struct miqt_string */ QTextBrowser_searchPaths(const QTextBrowser* self) { QStringList _ret = self->searchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1243,20 +1243,20 @@ struct miqt_array /* of struct miqt_string */ QTextBrowser_searchPaths(const QT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QTextBrowser_setSearchPaths(QTextBrowser* self, struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; - paths_QList.reserve(paths.len); + QStringList paths_QStringList; + paths_QStringList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { QString paths_arr_i_QString = QString::fromUtf8(paths_arr[i].data, paths_arr[i].len); - paths_QList.push_back(paths_arr_i_QString); + paths_QStringList.push_back(paths_arr_i_QString); } - self->setSearchPaths(paths_QList); + self->setSearchPaths(paths_QStringList); } QVariant* QTextBrowser_loadResource(QTextBrowser* self, int type, QUrl* name) { diff --git a/qt/gen_qtextcodec.cpp b/qt/gen_qtextcodec.cpp index e78806aa3f..eeb058f614 100644 --- a/qt/gen_qtextcodec.cpp +++ b/qt/gen_qtextcodec.cpp @@ -35,8 +35,8 @@ QTextCodec* QTextCodec_codecForMib(int mib) { struct miqt_array /* of struct miqt_string */ QTextCodec_availableCodecs() { QList _ret = QTextCodec::availableCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -45,7 +45,7 @@ struct miqt_array /* of struct miqt_string */ QTextCodec_availableCodecs() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -53,12 +53,12 @@ struct miqt_array /* of struct miqt_string */ QTextCodec_availableCodecs() { struct miqt_array /* of int */ QTextCodec_availableMibs() { QList _ret = QTextCodec::availableMibs(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -173,8 +173,8 @@ struct miqt_string QTextCodec_name(const QTextCodec* self) { struct miqt_array /* of struct miqt_string */ QTextCodec_aliases(const QTextCodec* self) { QList _ret = self->aliases(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -183,7 +183,7 @@ struct miqt_array /* of struct miqt_string */ QTextCodec_aliases(const QTextCod _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextdocument.cpp b/qt/gen_qtextdocument.cpp index 29f30c00f3..f09e862a25 100644 --- a/qt/gen_qtextdocument.cpp +++ b/qt/gen_qtextdocument.cpp @@ -555,12 +555,12 @@ void QTextDocument_addResource(QTextDocument* self, int type, QUrl* name, QVaria struct miqt_array /* of QTextFormat* */ QTextDocument_allFormats(const QTextDocument* self) { QVector _ret = self->allFormats(); // Convert QList<> from C++ memory to manually-managed C memory - QTextFormat** _arr = static_cast(malloc(sizeof(QTextFormat*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextFormat** _arr = static_cast(malloc(sizeof(QTextFormat*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextFormat(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextdocumentwriter.cpp b/qt/gen_qtextdocumentwriter.cpp index 0b91e6186d..d8d6bab5ae 100644 --- a/qt/gen_qtextdocumentwriter.cpp +++ b/qt/gen_qtextdocumentwriter.cpp @@ -96,8 +96,8 @@ QTextCodec* QTextDocumentWriter_codec(const QTextDocumentWriter* self) { struct miqt_array /* of struct miqt_string */ QTextDocumentWriter_supportedDocumentFormats() { QList _ret = QTextDocumentWriter::supportedDocumentFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -106,7 +106,7 @@ struct miqt_array /* of struct miqt_string */ QTextDocumentWriter_supportedDocu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextedit.cpp b/qt/gen_qtextedit.cpp index 0d68a29d1d..4c209dd574 100644 --- a/qt/gen_qtextedit.cpp +++ b/qt/gen_qtextedit.cpp @@ -1462,12 +1462,12 @@ void QTextEdit_setExtraSelections(QTextEdit* self, struct miqt_array /* of QText struct miqt_array /* of QTextEdit__ExtraSelection* */ QTextEdit_extraSelections(const QTextEdit* self) { QList _ret = self->extraSelections(); // Convert QList<> from C++ memory to manually-managed C memory - QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextEdit::ExtraSelection(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextformat.cpp b/qt/gen_qtextformat.cpp index 491c956c3b..90689e13b6 100644 --- a/qt/gen_qtextformat.cpp +++ b/qt/gen_qtextformat.cpp @@ -176,24 +176,24 @@ QTextLength* QTextFormat_lengthProperty(const QTextFormat* self, int propertyId) struct miqt_array /* of QTextLength* */ QTextFormat_lengthVectorProperty(const QTextFormat* self, int propertyId) { QVector _ret = self->lengthVectorProperty(static_cast(propertyId)); // Convert QList<> from C++ memory to manually-managed C memory - QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLength(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QTextFormat_setProperty2(QTextFormat* self, int propertyId, struct miqt_array /* of QTextLength* */ lengths) { - QVector lengths_QList; - lengths_QList.reserve(lengths.len); + QVector lengths_QVector; + lengths_QVector.reserve(lengths.len); QTextLength** lengths_arr = static_cast(lengths.data); for(size_t i = 0; i < lengths.len; ++i) { - lengths_QList.push_back(*(lengths_arr[i])); + lengths_QVector.push_back(*(lengths_arr[i])); } - self->setProperty(static_cast(propertyId), lengths_QList); + self->setProperty(static_cast(propertyId), lengths_QVector); } struct miqt_map /* of int to QVariant* */ QTextFormat_properties(const QTextFormat* self) { @@ -376,14 +376,14 @@ struct miqt_string QTextCharFormat_fontFamily(const QTextCharFormat* self) { } void QTextCharFormat_setFontFamilies(QTextCharFormat* self, struct miqt_array /* of struct miqt_string */ families) { - QStringList families_QList; - families_QList.reserve(families.len); + QStringList families_QStringList; + families_QStringList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { QString families_arr_i_QString = QString::fromUtf8(families_arr[i].data, families_arr[i].len); - families_QList.push_back(families_arr_i_QString); + families_QStringList.push_back(families_arr_i_QString); } - self->setFontFamilies(families_QList); + self->setFontFamilies(families_QStringList); } QVariant* QTextCharFormat_fontFamilies(const QTextCharFormat* self) { @@ -626,21 +626,21 @@ struct miqt_string QTextCharFormat_anchorName(const QTextCharFormat* self) { } void QTextCharFormat_setAnchorNames(QTextCharFormat* self, struct miqt_array /* of struct miqt_string */ names) { - QStringList names_QList; - names_QList.reserve(names.len); + QStringList names_QStringList; + names_QStringList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { QString names_arr_i_QString = QString::fromUtf8(names_arr[i].data, names_arr[i].len); - names_QList.push_back(names_arr_i_QString); + names_QStringList.push_back(names_arr_i_QString); } - self->setAnchorNames(names_QList); + self->setAnchorNames(names_QStringList); } struct miqt_array /* of struct miqt_string */ QTextCharFormat_anchorNames(const QTextCharFormat* self) { QStringList _ret = self->anchorNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -651,7 +651,7 @@ struct miqt_array /* of struct miqt_string */ QTextCharFormat_anchorNames(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -814,12 +814,12 @@ void QTextBlockFormat_setTabPositions(QTextBlockFormat* self, struct miqt_array struct miqt_array /* of QTextOption__Tab* */ QTextBlockFormat_tabPositions(const QTextBlockFormat* self) { QList _ret = self->tabPositions(); // Convert QList<> from C++ memory to manually-managed C memory - QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextOption::Tab(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1131,24 +1131,24 @@ void QTextTableFormat_setColumns(QTextTableFormat* self, int columns) { } void QTextTableFormat_setColumnWidthConstraints(QTextTableFormat* self, struct miqt_array /* of QTextLength* */ constraints) { - QVector constraints_QList; - constraints_QList.reserve(constraints.len); + QVector constraints_QVector; + constraints_QVector.reserve(constraints.len); QTextLength** constraints_arr = static_cast(constraints.data); for(size_t i = 0; i < constraints.len; ++i) { - constraints_QList.push_back(*(constraints_arr[i])); + constraints_QVector.push_back(*(constraints_arr[i])); } - self->setColumnWidthConstraints(constraints_QList); + self->setColumnWidthConstraints(constraints_QVector); } struct miqt_array /* of QTextLength* */ QTextTableFormat_columnWidthConstraints(const QTextTableFormat* self) { QVector _ret = self->columnWidthConstraints(); // Convert QList<> from C++ memory to manually-managed C memory - QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLength(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextlayout.cpp b/qt/gen_qtextlayout.cpp index ea25ae3a46..ced368fc68 100644 --- a/qt/gen_qtextlayout.cpp +++ b/qt/gen_qtextlayout.cpp @@ -187,12 +187,12 @@ void QTextLayout_setAdditionalFormats(QTextLayout* self, struct miqt_array /* of struct miqt_array /* of QTextLayout__FormatRange* */ QTextLayout_additionalFormats(const QTextLayout* self) { QList _ret = self->additionalFormats(); // Convert QList<> from C++ memory to manually-managed C memory - QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLayout::FormatRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -202,24 +202,24 @@ void QTextLayout_clearAdditionalFormats(QTextLayout* self) { } void QTextLayout_setFormats(QTextLayout* self, struct miqt_array /* of QTextLayout__FormatRange* */ overrides) { - QVector overrides_QList; - overrides_QList.reserve(overrides.len); + QVector overrides_QVector; + overrides_QVector.reserve(overrides.len); QTextLayout__FormatRange** overrides_arr = static_cast(overrides.data); for(size_t i = 0; i < overrides.len; ++i) { - overrides_QList.push_back(*(overrides_arr[i])); + overrides_QVector.push_back(*(overrides_arr[i])); } - self->setFormats(overrides_QList); + self->setFormats(overrides_QVector); } struct miqt_array /* of QTextLayout__FormatRange* */ QTextLayout_formats(const QTextLayout* self) { QVector _ret = self->formats(); // Convert QList<> from C++ memory to manually-managed C memory - QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLayout::FormatRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -330,12 +330,12 @@ double QTextLayout_maximumWidth(const QTextLayout* self) { struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRuns(const QTextLayout* self) { QList _ret = self->glyphRuns(); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -353,34 +353,34 @@ int QTextLayout_previousCursorPosition2(const QTextLayout* self, int oldPos, int } void QTextLayout_draw2(const QTextLayout* self, QPainter* p, QPointF* pos, struct miqt_array /* of QTextLayout__FormatRange* */ selections) { - QVector selections_QList; - selections_QList.reserve(selections.len); + QVector selections_QVector; + selections_QVector.reserve(selections.len); QTextLayout__FormatRange** selections_arr = static_cast(selections.data); for(size_t i = 0; i < selections.len; ++i) { - selections_QList.push_back(*(selections_arr[i])); + selections_QVector.push_back(*(selections_arr[i])); } - self->draw(p, *pos, selections_QList); + self->draw(p, *pos, selections_QVector); } void QTextLayout_draw3(const QTextLayout* self, QPainter* p, QPointF* pos, struct miqt_array /* of QTextLayout__FormatRange* */ selections, QRectF* clip) { - QVector selections_QList; - selections_QList.reserve(selections.len); + QVector selections_QVector; + selections_QVector.reserve(selections.len); QTextLayout__FormatRange** selections_arr = static_cast(selections.data); for(size_t i = 0; i < selections.len; ++i) { - selections_QList.push_back(*(selections_arr[i])); + selections_QVector.push_back(*(selections_arr[i])); } - self->draw(p, *pos, selections_QList, *clip); + self->draw(p, *pos, selections_QVector, *clip); } struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRunsWithFrom(const QTextLayout* self, int from) { QList _ret = self->glyphRuns(static_cast(from)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -388,12 +388,12 @@ struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRunsWithFrom(const QText struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRuns2(const QTextLayout* self, int from, int length) { QList _ret = self->glyphRuns(static_cast(from), static_cast(length)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -524,12 +524,12 @@ void QTextLine_draw(const QTextLine* self, QPainter* p, QPointF* point) { struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRuns(const QTextLine* self) { QList _ret = self->glyphRuns(); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -555,12 +555,12 @@ void QTextLine_draw2(const QTextLine* self, QPainter* p, QPointF* point, QTextLa struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRunsWithFrom(const QTextLine* self, int from) { QList _ret = self->glyphRuns(static_cast(from)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -568,12 +568,12 @@ struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRunsWithFrom(const QTextLi struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRuns2(const QTextLine* self, int from, int length) { QList _ret = self->glyphRuns(static_cast(from), static_cast(length)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextlist.cpp b/qt/gen_qtextlist.cpp index 00c149dd56..abfa8e02b3 100644 --- a/qt/gen_qtextlist.cpp +++ b/qt/gen_qtextlist.cpp @@ -508,12 +508,12 @@ struct miqt_array /* of QTextBlock* */ QTextList_protectedbase_blockList(bool* *_dynamic_cast_ok = true; QList _ret = self_cast->blockList(); // Convert QList<> from C++ memory to manually-managed C memory - QTextBlock** _arr = static_cast(malloc(sizeof(QTextBlock*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextBlock** _arr = static_cast(malloc(sizeof(QTextBlock*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextBlock(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextobject.cpp b/qt/gen_qtextobject.cpp index c841771e47..eac2bd6355 100644 --- a/qt/gen_qtextobject.cpp +++ b/qt/gen_qtextobject.cpp @@ -436,12 +436,12 @@ void QTextFrame_setLayoutData(QTextFrame* self, QTextFrameLayoutData* data) { struct miqt_array /* of QTextFrame* */ QTextFrame_childFrames(const QTextFrame* self) { QList _ret = self->childFrames(); // Convert QList<> from C++ memory to manually-managed C memory - QTextFrame** _arr = static_cast(malloc(sizeof(QTextFrame*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextFrame** _arr = static_cast(malloc(sizeof(QTextFrame*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -750,12 +750,12 @@ struct miqt_string QTextBlock_text(const QTextBlock* self) { struct miqt_array /* of QTextLayout__FormatRange* */ QTextBlock_textFormats(const QTextBlock* self) { QVector _ret = self->textFormats(); // Convert QList<> from C++ memory to manually-managed C memory - QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLayout::FormatRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -902,12 +902,12 @@ struct miqt_string QTextFragment_text(const QTextFragment* self) { struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRuns(const QTextFragment* self) { QList _ret = self->glyphRuns(); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -915,12 +915,12 @@ struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRuns(const QTextFragme struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRunsWithFrom(const QTextFragment* self, int from) { QList _ret = self->glyphRuns(static_cast(from)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -928,12 +928,12 @@ struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRunsWithFrom(const QTe struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRuns2(const QTextFragment* self, int from, int length) { QList _ret = self->glyphRuns(static_cast(from), static_cast(length)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtextoption.cpp b/qt/gen_qtextoption.cpp index a2c2b9756b..173776f35f 100644 --- a/qt/gen_qtextoption.cpp +++ b/qt/gen_qtextoption.cpp @@ -96,12 +96,12 @@ void QTextOption_setTabArray(QTextOption* self, struct miqt_array /* of double * struct miqt_array /* of double */ QTextOption_tabArray(const QTextOption* self) { QList _ret = self->tabArray(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -119,12 +119,12 @@ void QTextOption_setTabs(QTextOption* self, struct miqt_array /* of QTextOption_ struct miqt_array /* of QTextOption__Tab* */ QTextOption_tabs(const QTextOption* self) { QList _ret = self->tabs(); // Convert QList<> from C++ memory to manually-managed C memory - QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextOption::Tab(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtimezone.cpp b/qt/gen_qtimezone.cpp index eae29c505b..ef49fc0c4c 100644 --- a/qt/gen_qtimezone.cpp +++ b/qt/gen_qtimezone.cpp @@ -167,12 +167,12 @@ QTimeZone__OffsetData* QTimeZone_previousTransition(const QTimeZone* self, QDate struct miqt_array /* of QTimeZone__OffsetData* */ QTimeZone_transitions(const QTimeZone* self, QDateTime* fromDateTime, QDateTime* toDateTime) { QTimeZone::OffsetDataList _ret = self->transitions(*fromDateTime, *toDateTime); // Convert QList<> from C++ memory to manually-managed C memory - QTimeZone__OffsetData** _arr = static_cast(malloc(sizeof(QTimeZone__OffsetData*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTimeZone__OffsetData** _arr = static_cast(malloc(sizeof(QTimeZone__OffsetData*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTimeZone::OffsetData(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -202,8 +202,8 @@ bool QTimeZone_isTimeZoneIdAvailable(struct miqt_string ianaId) { struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIds() { QList _ret = QTimeZone::availableTimeZoneIds(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -212,7 +212,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIds() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -220,8 +220,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIds() struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWithCountry(int country) { QList _ret = QTimeZone::availableTimeZoneIds(static_cast(country)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -230,7 +230,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWit _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -238,8 +238,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWit struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWithOffsetSeconds(int offsetSeconds) { QList _ret = QTimeZone::availableTimeZoneIds(static_cast(offsetSeconds)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -248,7 +248,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWit _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -287,8 +287,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds(stru QByteArray windowsId_QByteArray(windowsId.data, windowsId.len); QList _ret = QTimeZone::windowsIdToIanaIds(windowsId_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -297,7 +297,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds(stru _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -306,8 +306,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds2(str QByteArray windowsId_QByteArray(windowsId.data, windowsId.len); QList _ret = QTimeZone::windowsIdToIanaIds(windowsId_QByteArray, static_cast(country)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -316,7 +316,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds2(str _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtouchdevice.cpp b/qt/gen_qtouchdevice.cpp index 7b7a3966fe..3a37a4cd0f 100644 --- a/qt/gen_qtouchdevice.cpp +++ b/qt/gen_qtouchdevice.cpp @@ -21,12 +21,12 @@ QTouchDevice* QTouchDevice_new() { struct miqt_array /* of QTouchDevice* */ QTouchDevice_devices() { QList _ret = QTouchDevice::devices(); // Convert QList<> from C++ memory to manually-managed C memory - QTouchDevice** _arr = static_cast(malloc(sizeof(QTouchDevice*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTouchDevice** _arr = static_cast(malloc(sizeof(QTouchDevice*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = (QTouchDevice*) _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtransposeproxymodel.cpp b/qt/gen_qtransposeproxymodel.cpp index 8f88388a7f..9e443d1194 100644 --- a/qt/gen_qtransposeproxymodel.cpp +++ b/qt/gen_qtransposeproxymodel.cpp @@ -705,12 +705,12 @@ class MiqtVirtualQTransposeProxyModel final : public QTransposeProxyModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QTransposeProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -775,14 +775,14 @@ class MiqtVirtualQTransposeProxyModel final : public QTransposeProxyModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QTransposeProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QTransposeProxyModel_virtualbase_mimeTypes(const void* self); @@ -837,13 +837,13 @@ class MiqtVirtualQTransposeProxyModel final : public QTransposeProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTransposeProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QTransposeProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -1669,13 +1669,13 @@ bool QTransposeProxyModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QTransposeProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QTransposeProxyModel::mimeData(indexes_QList); + return static_cast(self)->QTransposeProxyModel::mimeData(indexes_QModelIndexList); } bool QTransposeProxyModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -1719,8 +1719,8 @@ bool QTransposeProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) struct miqt_array /* of struct miqt_string */ QTransposeProxyModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QTransposeProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1731,7 +1731,7 @@ struct miqt_array /* of struct miqt_string */ QTransposeProxyModel_virtualbase_ _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1779,12 +1779,12 @@ bool QTransposeProxyModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QTransposeProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QTransposeProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1950,13 +1950,13 @@ void QTransposeProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QTransposeProxyModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -2143,19 +2143,19 @@ void QTransposeProxyModel_protectedbase_changePersistentIndexList(bool* _dynamic } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QTransposeProxyModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -2168,12 +2168,12 @@ struct miqt_array /* of QModelIndex* */ QTransposeProxyModel_protectedbase_pers *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtreeview.cpp b/qt/gen_qtreeview.cpp index cfd310a131..6058030f68 100644 --- a/qt/gen_qtreeview.cpp +++ b/qt/gen_qtreeview.cpp @@ -345,12 +345,12 @@ class MiqtVirtualQTreeView final : public QTreeView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTreeView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -550,13 +550,13 @@ class MiqtVirtualQTreeView final : public QTreeView { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTreeView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QTreeView_virtualbase_selectedIndexes(const void* self); @@ -2050,13 +2050,13 @@ void QTreeView_reset(QTreeView* self) { } void QTreeView_dataChanged(QTreeView* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - self->dataChanged(*topLeft, *bottomRight, roles_QList); + self->dataChanged(*topLeft, *bottomRight, roles_QVector); } void QTreeView_selectAll(QTreeView* self) { @@ -2319,13 +2319,13 @@ bool QTreeView_override_virtual_dataChanged(void* self, intptr_t slot) { } void QTreeView_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QTreeView::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QTreeView::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QTreeView_override_virtual_selectAll(void* self, intptr_t slot) { @@ -2481,12 +2481,12 @@ bool QTreeView_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QTreeView_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QTreeView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qtreewidget.cpp b/qt/gen_qtreewidget.cpp index e9436dd378..f3cfccb6b5 100644 --- a/qt/gen_qtreewidget.cpp +++ b/qt/gen_qtreewidget.cpp @@ -317,14 +317,14 @@ QTreeWidgetItem* QTreeWidgetItem_new() { } QTreeWidgetItem* QTreeWidgetItem_new2(struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQTreeWidgetItem(strings_QList); + return new (std::nothrow) MiqtVirtualQTreeWidgetItem(strings_QStringList); } QTreeWidgetItem* QTreeWidgetItem_new3(QTreeWidget* treeview) { @@ -332,14 +332,14 @@ QTreeWidgetItem* QTreeWidgetItem_new3(QTreeWidget* treeview) { } QTreeWidgetItem* QTreeWidgetItem_new4(QTreeWidget* treeview, struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQTreeWidgetItem(treeview, strings_QList); + return new (std::nothrow) MiqtVirtualQTreeWidgetItem(treeview, strings_QStringList); } QTreeWidgetItem* QTreeWidgetItem_new5(QTreeWidget* treeview, QTreeWidgetItem* after) { @@ -351,14 +351,14 @@ QTreeWidgetItem* QTreeWidgetItem_new6(QTreeWidgetItem* parent) { } QTreeWidgetItem* QTreeWidgetItem_new7(QTreeWidgetItem* parent, struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQTreeWidgetItem(parent, strings_QList); + return new (std::nothrow) MiqtVirtualQTreeWidgetItem(parent, strings_QStringList); } QTreeWidgetItem* QTreeWidgetItem_new8(QTreeWidgetItem* parent, QTreeWidgetItem* after) { @@ -374,14 +374,14 @@ QTreeWidgetItem* QTreeWidgetItem_new10(int type) { } QTreeWidgetItem* QTreeWidgetItem_new11(struct miqt_array /* of struct miqt_string */ strings, int type) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQTreeWidgetItem(strings_QList, static_cast(type)); + return new (std::nothrow) MiqtVirtualQTreeWidgetItem(strings_QStringList, static_cast(type)); } QTreeWidgetItem* QTreeWidgetItem_new12(QTreeWidget* treeview, int type) { @@ -389,14 +389,14 @@ QTreeWidgetItem* QTreeWidgetItem_new12(QTreeWidget* treeview, int type) { } QTreeWidgetItem* QTreeWidgetItem_new13(QTreeWidget* treeview, struct miqt_array /* of struct miqt_string */ strings, int type) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQTreeWidgetItem(treeview, strings_QList, static_cast(type)); + return new (std::nothrow) MiqtVirtualQTreeWidgetItem(treeview, strings_QStringList, static_cast(type)); } QTreeWidgetItem* QTreeWidgetItem_new14(QTreeWidget* treeview, QTreeWidgetItem* after, int type) { @@ -408,14 +408,14 @@ QTreeWidgetItem* QTreeWidgetItem_new15(QTreeWidgetItem* parent, int type) { } QTreeWidgetItem* QTreeWidgetItem_new16(QTreeWidgetItem* parent, struct miqt_array /* of struct miqt_string */ strings, int type) { - QStringList strings_QList; - strings_QList.reserve(strings.len); + QStringList strings_QStringList; + strings_QStringList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { QString strings_arr_i_QString = QString::fromUtf8(strings_arr[i].data, strings_arr[i].len); - strings_QList.push_back(strings_arr_i_QString); + strings_QStringList.push_back(strings_arr_i_QString); } - return new (std::nothrow) MiqtVirtualQTreeWidgetItem(parent, strings_QList, static_cast(type)); + return new (std::nothrow) MiqtVirtualQTreeWidgetItem(parent, strings_QStringList, static_cast(type)); } QTreeWidgetItem* QTreeWidgetItem_new17(QTreeWidgetItem* parent, QTreeWidgetItem* after, int type) { @@ -708,12 +708,12 @@ void QTreeWidgetItem_insertChildren(QTreeWidgetItem* self, int index, struct miq struct miqt_array /* of QTreeWidgetItem* */ QTreeWidgetItem_takeChildren(QTreeWidgetItem* self) { QList _ret = self->takeChildren(); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -876,14 +876,14 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QTreeWidget_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QTreeWidget_virtualbase_mimeTypes(const void* self); @@ -899,12 +899,12 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { const QList items_ret = items; // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** items_arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * items_ret.length())); - for (size_t i = 0, e = items_ret.length(); i < e; ++i) { + QTreeWidgetItem** items_arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * items_ret.size())); + for (size_t i = 0, e = items_ret.size(); i < e; ++i) { items_arr[i] = items_ret[i]; } struct miqt_array items_out; - items_out.len = items_ret.length(); + items_out.len = items_ret.size(); items_out.data = static_cast(items_arr); struct miqt_array /* of QTreeWidgetItem* */ sigval1 = items_out; QMimeData* callback_return_value = miqt_exec_callback_QTreeWidget_mimeData(this, handle__mimeData, sigval1); @@ -1115,12 +1115,12 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTreeWidget_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -1320,13 +1320,13 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTreeWidget_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QTreeWidget_virtualbase_selectedIndexes(const void* self); @@ -2656,14 +2656,14 @@ void QTreeWidget_setHeaderItem(QTreeWidget* self, QTreeWidgetItem* item) { } void QTreeWidget_setHeaderLabels(QTreeWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; - labels_QList.reserve(labels.len); + QStringList labels_QStringList; + labels_QStringList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { QString labels_arr_i_QString = QString::fromUtf8(labels_arr[i].data, labels_arr[i].len); - labels_QList.push_back(labels_arr_i_QString); + labels_QStringList.push_back(labels_arr_i_QString); } - self->setHeaderLabels(labels_QList); + self->setHeaderLabels(labels_QStringList); } void QTreeWidget_setHeaderLabel(QTreeWidget* self, struct miqt_string label) { @@ -2750,12 +2750,12 @@ void QTreeWidget_setItemSelected(QTreeWidget* self, QTreeWidgetItem* item, bool struct miqt_array /* of QTreeWidgetItem* */ QTreeWidget_selectedItems(const QTreeWidget* self) { QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2764,12 +2764,12 @@ struct miqt_array /* of QTreeWidgetItem* */ QTreeWidget_findItems(const QTreeWi QString text_QString = QString::fromUtf8(text.data, text.len); QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3006,12 +3006,12 @@ struct miqt_array /* of QTreeWidgetItem* */ QTreeWidget_findItems2(const QTreeW QString text_QString = QString::fromUtf8(text.data, text.len); QList _ret = self->findItems(text_QString, static_cast(flags), static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3061,8 +3061,8 @@ bool QTreeWidget_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QTreeWidget_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QTreeWidget::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -3073,7 +3073,7 @@ struct miqt_array /* of struct miqt_string */ QTreeWidget_virtualbase_mimeTypes _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3251,13 +3251,13 @@ bool QTreeWidget_override_virtual_dataChanged(void* self, intptr_t slot) { } void QTreeWidget_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QTreeWidget::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QTreeWidget::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QTreeWidget_override_virtual_selectAll(void* self, intptr_t slot) { @@ -3413,12 +3413,12 @@ bool QTreeWidget_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QTreeWidget_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QTreeWidget::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -4387,12 +4387,12 @@ struct miqt_array /* of QTreeWidgetItem* */ QTreeWidget_protectedbase_items(boo *_dynamic_cast_ok = true; QList _ret = self_cast->items(data); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qundogroup.cpp b/qt/gen_qundogroup.cpp index 06731cc256..bb69ff92ce 100644 --- a/qt/gen_qundogroup.cpp +++ b/qt/gen_qundogroup.cpp @@ -226,12 +226,12 @@ void QUndoGroup_removeStack(QUndoGroup* self, QUndoStack* stack) { struct miqt_array /* of QUndoStack* */ QUndoGroup_stacks(const QUndoGroup* self) { QList _ret = self->stacks(); // Convert QList<> from C++ memory to manually-managed C memory - QUndoStack** _arr = static_cast(malloc(sizeof(QUndoStack*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUndoStack** _arr = static_cast(malloc(sizeof(QUndoStack*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qundoview.cpp b/qt/gen_qundoview.cpp index 63a8fe9e41..8e0cd61b42 100644 --- a/qt/gen_qundoview.cpp +++ b/qt/gen_qundoview.cpp @@ -324,12 +324,12 @@ class MiqtVirtualQUndoView final : public QUndoView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QVector& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QUndoView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -664,13 +664,13 @@ class MiqtVirtualQUndoView final : public QUndoView { } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QUndoView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QUndoView_virtualbase_selectedIndexes(const void* self); @@ -2024,13 +2024,13 @@ bool QUndoView_override_virtual_dataChanged(void* self, intptr_t slot) { } void QUndoView_virtualbase_dataChanged(void* self, QModelIndex* topLeft, QModelIndex* bottomRight, struct miqt_array /* of int */ roles) { - QVector roles_QList; - roles_QList.reserve(roles.len); + QVector roles_QVector; + roles_QVector.reserve(roles.len); int* roles_arr = static_cast(roles.data); for(size_t i = 0; i < roles.len; ++i) { - roles_QList.push_back(static_cast(roles_arr[i])); + roles_QVector.push_back(static_cast(roles_arr[i])); } - static_cast(self)->QUndoView::dataChanged(*topLeft, *bottomRight, roles_QList); + static_cast(self)->QUndoView::dataChanged(*topLeft, *bottomRight, roles_QVector); } bool QUndoView_override_virtual_rowsInserted(void* self, intptr_t slot) { @@ -2298,12 +2298,12 @@ bool QUndoView_override_virtual_selectedIndexes(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QUndoView_virtualbase_selectedIndexes(const void* self) { QModelIndexList _ret = static_cast(self)->QUndoView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qurl.cpp b/qt/gen_qurl.cpp index aec5c8f119..3680e99e4c 100644 --- a/qt/gen_qurl.cpp +++ b/qt/gen_qurl.cpp @@ -418,8 +418,8 @@ struct miqt_string QUrl_toAce(struct miqt_string param1) { struct miqt_array /* of struct miqt_string */ QUrl_idnWhitelist() { QStringList _ret = QUrl::idnWhitelist(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -430,7 +430,7 @@ struct miqt_array /* of struct miqt_string */ QUrl_idnWhitelist() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -444,8 +444,8 @@ struct miqt_array /* of struct miqt_string */ QUrl_toStringList(struct miqt_arr } QStringList _ret = QUrl::toStringList(uris_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -456,40 +456,40 @@ struct miqt_array /* of struct miqt_string */ QUrl_toStringList(struct miqt_arr _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QUrl* */ QUrl_fromStringList(struct miqt_array /* of struct miqt_string */ uris) { - QStringList uris_QList; - uris_QList.reserve(uris.len); + QStringList uris_QStringList; + uris_QStringList.reserve(uris.len); struct miqt_string* uris_arr = static_cast(uris.data); for(size_t i = 0; i < uris.len; ++i) { QString uris_arr_i_QString = QString::fromUtf8(uris_arr[i].data, uris_arr[i].len); - uris_QList.push_back(uris_arr_i_QString); + uris_QStringList.push_back(uris_arr_i_QString); } - QList _ret = QUrl::fromStringList(uris_QList); + QList _ret = QUrl::fromStringList(uris_QStringList); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QUrl_setIdnWhitelist(struct miqt_array /* of struct miqt_string */ idnWhitelist) { - QStringList idnWhitelist_QList; - idnWhitelist_QList.reserve(idnWhitelist.len); + QStringList idnWhitelist_QStringList; + idnWhitelist_QStringList.reserve(idnWhitelist.len); struct miqt_string* idnWhitelist_arr = static_cast(idnWhitelist.data); for(size_t i = 0; i < idnWhitelist.len; ++i) { QString idnWhitelist_arr_i_QString = QString::fromUtf8(idnWhitelist_arr[i].data, idnWhitelist_arr[i].len); - idnWhitelist_QList.push_back(idnWhitelist_arr_i_QString); + idnWhitelist_QStringList.push_back(idnWhitelist_arr_i_QString); } - QUrl::setIdnWhitelist(idnWhitelist_QList); + QUrl::setIdnWhitelist(idnWhitelist_QStringList); } void QUrl_setUrl2(QUrl* self, struct miqt_string url, int mode) { @@ -686,21 +686,21 @@ struct miqt_string QUrl_toPercentEncoding3(struct miqt_string param1, struct miq } struct miqt_array /* of QUrl* */ QUrl_fromStringList2(struct miqt_array /* of struct miqt_string */ uris, int mode) { - QStringList uris_QList; - uris_QList.reserve(uris.len); + QStringList uris_QStringList; + uris_QStringList.reserve(uris.len); struct miqt_string* uris_arr = static_cast(uris.data); for(size_t i = 0; i < uris.len; ++i) { QString uris_arr_i_QString = QString::fromUtf8(uris_arr[i].data, uris_arr[i].len); - uris_QList.push_back(uris_arr_i_QString); + uris_QStringList.push_back(uris_arr_i_QString); } - QList _ret = QUrl::fromStringList(uris_QList, static_cast(mode)); + QList _ret = QUrl::fromStringList(uris_QStringList, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qurlquery.cpp b/qt/gen_qurlquery.cpp index 5da8294885..94a6b3c5e0 100644 --- a/qt/gen_qurlquery.cpp +++ b/qt/gen_qurlquery.cpp @@ -121,8 +121,8 @@ void QUrlQuery_setQueryItems(QUrlQuery* self, struct miqt_array /* of struct miq struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QUrlQuery_queryItems(const QUrlQuery* self) { QList> _ret = self->queryItems(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -150,7 +150,7 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -187,8 +187,8 @@ struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues(cons QString key_QString = QString::fromUtf8(key.data, key.len); QStringList _ret = self->allQueryItemValues(key_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -199,7 +199,7 @@ struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -242,8 +242,8 @@ struct miqt_string QUrlQuery_toStringWithEncoding(const QUrlQuery* self, int enc struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QUrlQuery_queryItemsWithEncoding(const QUrlQuery* self, int encoding) { QList> _ret = self->queryItems(static_cast(encoding)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -271,7 +271,7 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -292,8 +292,8 @@ struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues2(con QString key_QString = QString::fromUtf8(key.data, key.len); QStringList _ret = self->allQueryItemValues(key_QString, static_cast(encoding)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -304,7 +304,7 @@ struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues2(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qvariant.cpp b/qt/gen_qvariant.cpp index a0a40eaafd..ea5750cb8a 100644 --- a/qt/gen_qvariant.cpp +++ b/qt/gen_qvariant.cpp @@ -118,14 +118,14 @@ QVariant* QVariant_new17(struct miqt_string string) { } QVariant* QVariant_new18(struct miqt_array /* of struct miqt_string */ stringlist) { - QStringList stringlist_QList; - stringlist_QList.reserve(stringlist.len); + QStringList stringlist_QStringList; + stringlist_QStringList.reserve(stringlist.len); struct miqt_string* stringlist_arr = static_cast(stringlist.data); for(size_t i = 0; i < stringlist.len; ++i) { QString stringlist_arr_i_QString = QString::fromUtf8(stringlist_arr[i].data, stringlist_arr[i].len); - stringlist_QList.push_back(stringlist_arr_i_QString); + stringlist_QStringList.push_back(stringlist_arr_i_QString); } - return new (std::nothrow) QVariant(stringlist_QList); + return new (std::nothrow) QVariant(stringlist_QStringList); } QVariant* QVariant_new19(QChar* qchar) { @@ -369,8 +369,8 @@ struct miqt_string QVariant_toString(const QVariant* self) { struct miqt_array /* of struct miqt_string */ QVariant_toStringList(const QVariant* self) { QStringList _ret = self->toStringList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -381,7 +381,7 @@ struct miqt_array /* of struct miqt_string */ QVariant_toStringList(const QVari _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -405,12 +405,12 @@ QDateTime* QVariant_toDateTime(const QVariant* self) { struct miqt_array /* of QVariant* */ QVariant_toList(const QVariant* self) { QList _ret = self->toList(); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qvariantanimation.cpp b/qt/gen_qvariantanimation.cpp index 401a00261b..6555c04124 100644 --- a/qt/gen_qvariantanimation.cpp +++ b/qt/gen_qvariantanimation.cpp @@ -356,8 +356,8 @@ void QVariantAnimation_setKeyValueAt(QVariantAnimation* self, double step, QVari struct miqt_array /* of struct miqt_map tuple of double and QVariant* */ QVariantAnimation_keyValues(const QVariantAnimation* self) { QVariantAnimation::KeyValues _ret = self->keyValues(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QVariant* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QVariant* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QVariant* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QVariant* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _vv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _vv_first_arr = static_cast(malloc(sizeof(double))); @@ -371,14 +371,14 @@ struct miqt_array /* of struct miqt_map tuple of double and QVariant* */ QVa _arr[i] = _vv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QVariantAnimation_setKeyValues(QVariantAnimation* self, struct miqt_array /* of struct miqt_map tuple of double and QVariant* */ values) { - QVariantAnimation::KeyValues values_QList; - values_QList.reserve(values.len); + QVariantAnimation::KeyValues values_QVariantAnimation__KeyValues; + values_QVariantAnimation__KeyValues.reserve(values.len); struct miqt_map /* tuple of double and QVariant* */ * values_arr = static_cast(values.data); for(size_t i = 0; i < values.len; ++i) { QPair values_arr_i_QPair; @@ -386,9 +386,9 @@ void QVariantAnimation_setKeyValues(QVariantAnimation* self, struct miqt_array / QVariant** values_arr_i_second_arr = static_cast(values_arr[i].values); values_arr_i_QPair.first = static_cast(values_arr_i_first_arr[0]); values_arr_i_QPair.second = *(values_arr_i_second_arr[0]); - values_QList.push_back(values_arr_i_QPair); + values_QVariantAnimation__KeyValues.push_back(values_arr_i_QPair); } - self->setKeyValues(values_QList); + self->setKeyValues(values_QVariantAnimation__KeyValues); } QVariant* QVariantAnimation_currentValue(const QVariantAnimation* self) { diff --git a/qt/gen_qversionnumber.cpp b/qt/gen_qversionnumber.cpp index 3e3dda7b83..2ce63a47b8 100644 --- a/qt/gen_qversionnumber.cpp +++ b/qt/gen_qversionnumber.cpp @@ -19,13 +19,13 @@ QVersionNumber* QVersionNumber_new() { } QVersionNumber* QVersionNumber_new2(struct miqt_array /* of int */ seg) { - QVector seg_QList; - seg_QList.reserve(seg.len); + QVector seg_QVector; + seg_QVector.reserve(seg.len); int* seg_arr = static_cast(seg.data); for(size_t i = 0; i < seg.len; ++i) { - seg_QList.push_back(static_cast(seg_arr[i])); + seg_QVector.push_back(static_cast(seg_arr[i])); } - return new (std::nothrow) QVersionNumber(seg_QList); + return new (std::nothrow) QVersionNumber(seg_QVector); } QVersionNumber* QVersionNumber_new3(int maj) { @@ -67,12 +67,12 @@ QVersionNumber* QVersionNumber_normalized(const QVersionNumber* self) { struct miqt_array /* of int */ QVersionNumber_segments(const QVersionNumber* self) { QVector _ret = self->segments(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qwidget.cpp b/qt/gen_qwidget.cpp index 08fe3f801e..8805025abc 100644 --- a/qt/gen_qwidget.cpp +++ b/qt/gen_qwidget.cpp @@ -2007,12 +2007,12 @@ void QWidget_removeAction(QWidget* self, QAction* action) { struct miqt_array /* of QAction* */ QWidget_actions(const QWidget* self) { QList _ret = self->actions(); // Convert QList<> from C++ memory to manually-managed C memory - QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qwidgetaction.cpp b/qt/gen_qwidgetaction.cpp index a37bd84653..9a5e4f71c5 100644 --- a/qt/gen_qwidgetaction.cpp +++ b/qt/gen_qwidgetaction.cpp @@ -435,12 +435,12 @@ struct miqt_array /* of QWidget* */ QWidgetAction_protectedbase_createdWidgets( *_dynamic_cast_ok = true; QList _ret = self_cast->createdWidgets(); // Convert QList<> from C++ memory to manually-managed C memory - QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qwizard.cpp b/qt/gen_qwizard.cpp index 526f5f844e..9c6b768bbb 100644 --- a/qt/gen_qwizard.cpp +++ b/qt/gen_qwizard.cpp @@ -1192,12 +1192,12 @@ bool QWizard_hasVisitedPage(const QWizard* self, int id) { struct miqt_array /* of int */ QWizard_visitedPages(const QWizard* self) { QList _ret = self->visitedPages(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1205,12 +1205,12 @@ struct miqt_array /* of int */ QWizard_visitedPages(const QWizard* self) { struct miqt_array /* of int */ QWizard_visitedIds(const QWizard* self) { QList _ret = self->visitedIds(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1218,12 +1218,12 @@ struct miqt_array /* of int */ QWizard_visitedIds(const QWizard* self) { struct miqt_array /* of int */ QWizard_pageIds(const QWizard* self) { QList _ret = self->pageIds(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/gen_qxmlstream.cpp b/qt/gen_qxmlstream.cpp index 07c17f8fc6..64956bec3f 100644 --- a/qt/gen_qxmlstream.cpp +++ b/qt/gen_qxmlstream.cpp @@ -386,12 +386,12 @@ struct miqt_string QXmlStreamReader_readElementText(QXmlStreamReader* self) { struct miqt_array /* of QXmlStreamNamespaceDeclaration* */ QXmlStreamReader_namespaceDeclarations(const QXmlStreamReader* self) { QXmlStreamNamespaceDeclarations _ret = self->namespaceDeclarations(); // Convert QList<> from C++ memory to manually-managed C memory - QXmlStreamNamespaceDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNamespaceDeclaration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QXmlStreamNamespaceDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNamespaceDeclaration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QXmlStreamNamespaceDeclaration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -401,24 +401,24 @@ void QXmlStreamReader_addExtraNamespaceDeclaration(QXmlStreamReader* self, QXmlS } void QXmlStreamReader_addExtraNamespaceDeclarations(QXmlStreamReader* self, struct miqt_array /* of QXmlStreamNamespaceDeclaration* */ extraNamespaceDeclaractions) { - QXmlStreamNamespaceDeclarations extraNamespaceDeclaractions_QList; - extraNamespaceDeclaractions_QList.reserve(extraNamespaceDeclaractions.len); + QXmlStreamNamespaceDeclarations extraNamespaceDeclaractions_QXmlStreamNamespaceDeclarations; + extraNamespaceDeclaractions_QXmlStreamNamespaceDeclarations.reserve(extraNamespaceDeclaractions.len); QXmlStreamNamespaceDeclaration** extraNamespaceDeclaractions_arr = static_cast(extraNamespaceDeclaractions.data); for(size_t i = 0; i < extraNamespaceDeclaractions.len; ++i) { - extraNamespaceDeclaractions_QList.push_back(*(extraNamespaceDeclaractions_arr[i])); + extraNamespaceDeclaractions_QXmlStreamNamespaceDeclarations.push_back(*(extraNamespaceDeclaractions_arr[i])); } - self->addExtraNamespaceDeclarations(extraNamespaceDeclaractions_QList); + self->addExtraNamespaceDeclarations(extraNamespaceDeclaractions_QXmlStreamNamespaceDeclarations); } struct miqt_array /* of QXmlStreamNotationDeclaration* */ QXmlStreamReader_notationDeclarations(const QXmlStreamReader* self) { QXmlStreamNotationDeclarations _ret = self->notationDeclarations(); // Convert QList<> from C++ memory to manually-managed C memory - QXmlStreamNotationDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNotationDeclaration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QXmlStreamNotationDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNotationDeclaration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QXmlStreamNotationDeclaration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -426,12 +426,12 @@ struct miqt_array /* of QXmlStreamNotationDeclaration* */ QXmlStreamReader_nota struct miqt_array /* of QXmlStreamEntityDeclaration* */ QXmlStreamReader_entityDeclarations(const QXmlStreamReader* self) { QXmlStreamEntityDeclarations _ret = self->entityDeclarations(); // Convert QList<> from C++ memory to manually-managed C memory - QXmlStreamEntityDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamEntityDeclaration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QXmlStreamEntityDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamEntityDeclaration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QXmlStreamEntityDeclaration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qabstractvideosurface.cpp b/qt/multimedia/gen_qabstractvideosurface.cpp index 74b6644994..389288b38c 100644 --- a/qt/multimedia/gen_qabstractvideosurface.cpp +++ b/qt/multimedia/gen_qabstractvideosurface.cpp @@ -331,13 +331,13 @@ struct miqt_string QAbstractVideoSurface_trUtf8(const char* s) { struct miqt_array /* of int */ QAbstractVideoSurface_supportedPixelFormats(const QAbstractVideoSurface* self, int type) { QList _ret = self->supportedPixelFormats(static_cast(type)); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QVideoFrame::PixelFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudiodecoder.cpp b/qt/multimedia/gen_qaudiodecoder.cpp index eea930a4f0..8ad9c48489 100644 --- a/qt/multimedia/gen_qaudiodecoder.cpp +++ b/qt/multimedia/gen_qaudiodecoder.cpp @@ -547,14 +547,14 @@ struct miqt_string QAudioDecoder_trUtf83(const char* s, const char* c, int n) { int QAudioDecoder_hasSupport2(struct miqt_string mimeType, struct miqt_array /* of struct miqt_string */ codecs) { QString mimeType_QString = QString::fromUtf8(mimeType.data, mimeType.len); - QStringList codecs_QList; - codecs_QList.reserve(codecs.len); + QStringList codecs_QStringList; + codecs_QStringList.reserve(codecs.len); struct miqt_string* codecs_arr = static_cast(codecs.data); for(size_t i = 0; i < codecs.len; ++i) { QString codecs_arr_i_QString = QString::fromUtf8(codecs_arr[i].data, codecs_arr[i].len); - codecs_QList.push_back(codecs_arr_i_QString); + codecs_QStringList.push_back(codecs_arr_i_QString); } - QMultimedia::SupportEstimate _ret = QAudioDecoder::hasSupport(mimeType_QString, codecs_QList); + QMultimedia::SupportEstimate _ret = QAudioDecoder::hasSupport(mimeType_QString, codecs_QStringList); return static_cast(_ret); } diff --git a/qt/multimedia/gen_qaudiodeviceinfo.cpp b/qt/multimedia/gen_qaudiodeviceinfo.cpp index e01b0137eb..9aafcd7778 100644 --- a/qt/multimedia/gen_qaudiodeviceinfo.cpp +++ b/qt/multimedia/gen_qaudiodeviceinfo.cpp @@ -65,8 +65,8 @@ QAudioFormat* QAudioDeviceInfo_nearestFormat(const QAudioDeviceInfo* self, QAudi struct miqt_array /* of struct miqt_string */ QAudioDeviceInfo_supportedCodecs(const QAudioDeviceInfo* self) { QStringList _ret = self->supportedCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -77,7 +77,7 @@ struct miqt_array /* of struct miqt_string */ QAudioDeviceInfo_supportedCodecs( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -85,12 +85,12 @@ struct miqt_array /* of struct miqt_string */ QAudioDeviceInfo_supportedCodecs( struct miqt_array /* of int */ QAudioDeviceInfo_supportedSampleRates(const QAudioDeviceInfo* self) { QList _ret = self->supportedSampleRates(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -98,12 +98,12 @@ struct miqt_array /* of int */ QAudioDeviceInfo_supportedSampleRates(const QAud struct miqt_array /* of int */ QAudioDeviceInfo_supportedChannelCounts(const QAudioDeviceInfo* self) { QList _ret = self->supportedChannelCounts(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -111,12 +111,12 @@ struct miqt_array /* of int */ QAudioDeviceInfo_supportedChannelCounts(const QA struct miqt_array /* of int */ QAudioDeviceInfo_supportedSampleSizes(const QAudioDeviceInfo* self) { QList _ret = self->supportedSampleSizes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -124,13 +124,13 @@ struct miqt_array /* of int */ QAudioDeviceInfo_supportedSampleSizes(const QAud struct miqt_array /* of int */ QAudioDeviceInfo_supportedByteOrders(const QAudioDeviceInfo* self) { QList _ret = self->supportedByteOrders(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QAudioFormat::Endian _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -138,13 +138,13 @@ struct miqt_array /* of int */ QAudioDeviceInfo_supportedByteOrders(const QAudi struct miqt_array /* of int */ QAudioDeviceInfo_supportedSampleTypes(const QAudioDeviceInfo* self) { QList _ret = self->supportedSampleTypes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QAudioFormat::SampleType _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -171,12 +171,12 @@ QAudioDeviceInfo* QAudioDeviceInfo_defaultOutputDevice() { struct miqt_array /* of QAudioDeviceInfo* */ QAudioDeviceInfo_availableDevices(int mode) { QList _ret = QAudioDeviceInfo::availableDevices(static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QAudioDeviceInfo** _arr = static_cast(malloc(sizeof(QAudioDeviceInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAudioDeviceInfo** _arr = static_cast(malloc(sizeof(QAudioDeviceInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QAudioDeviceInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudioencodersettingscontrol.cpp b/qt/multimedia/gen_qaudioencodersettingscontrol.cpp index e687674742..94c9f08f4b 100644 --- a/qt/multimedia/gen_qaudioencodersettingscontrol.cpp +++ b/qt/multimedia/gen_qaudioencodersettingscontrol.cpp @@ -56,8 +56,8 @@ struct miqt_string QAudioEncoderSettingsControl_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QAudioEncoderSettingsControl_supportedAudioCodecs(const QAudioEncoderSettingsControl* self) { QStringList _ret = self->supportedAudioCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -68,7 +68,7 @@ struct miqt_array /* of struct miqt_string */ QAudioEncoderSettingsControl_supp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -88,12 +88,12 @@ struct miqt_string QAudioEncoderSettingsControl_codecDescription(const QAudioEnc struct miqt_array /* of int */ QAudioEncoderSettingsControl_supportedSampleRates(const QAudioEncoderSettingsControl* self, QAudioEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedSampleRates(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudioinputselectorcontrol.cpp b/qt/multimedia/gen_qaudioinputselectorcontrol.cpp index d71aadb110..7b6b757186 100644 --- a/qt/multimedia/gen_qaudioinputselectorcontrol.cpp +++ b/qt/multimedia/gen_qaudioinputselectorcontrol.cpp @@ -57,8 +57,8 @@ struct miqt_string QAudioInputSelectorControl_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QAudioInputSelectorControl_availableInputs(const QAudioInputSelectorControl* self) { QList _ret = self->availableInputs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -69,7 +69,7 @@ struct miqt_array /* of struct miqt_string */ QAudioInputSelectorControl_availa _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudiooutputselectorcontrol.cpp b/qt/multimedia/gen_qaudiooutputselectorcontrol.cpp index 04b11a401f..433f214ae6 100644 --- a/qt/multimedia/gen_qaudiooutputselectorcontrol.cpp +++ b/qt/multimedia/gen_qaudiooutputselectorcontrol.cpp @@ -57,8 +57,8 @@ struct miqt_string QAudioOutputSelectorControl_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QAudioOutputSelectorControl_availableOutputs(const QAudioOutputSelectorControl* self) { QList _ret = self->availableOutputs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -69,7 +69,7 @@ struct miqt_array /* of struct miqt_string */ QAudioOutputSelectorControl_avail _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudiorecorder.cpp b/qt/multimedia/gen_qaudiorecorder.cpp index e09d757053..77086161dc 100644 --- a/qt/multimedia/gen_qaudiorecorder.cpp +++ b/qt/multimedia/gen_qaudiorecorder.cpp @@ -247,8 +247,8 @@ struct miqt_string QAudioRecorder_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QAudioRecorder_audioInputs(const QAudioRecorder* self) { QStringList _ret = self->audioInputs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -259,7 +259,7 @@ struct miqt_array /* of struct miqt_string */ QAudioRecorder_audioInputs(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudiorolecontrol.cpp b/qt/multimedia/gen_qaudiorolecontrol.cpp index 2658f477c3..55517d9887 100644 --- a/qt/multimedia/gen_qaudiorolecontrol.cpp +++ b/qt/multimedia/gen_qaudiorolecontrol.cpp @@ -65,13 +65,13 @@ void QAudioRoleControl_setAudioRole(QAudioRoleControl* self, int role) { struct miqt_array /* of int */ QAudioRoleControl_supportedAudioRoles(const QAudioRoleControl* self) { QList _ret = self->supportedAudioRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QAudio::Role _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudiosystem.cpp b/qt/multimedia/gen_qaudiosystem.cpp index 58a8f4ed43..999436331d 100644 --- a/qt/multimedia/gen_qaudiosystem.cpp +++ b/qt/multimedia/gen_qaudiosystem.cpp @@ -83,8 +83,8 @@ struct miqt_string QAbstractAudioDeviceInfo_deviceName(const QAbstractAudioDevic struct miqt_array /* of struct miqt_string */ QAbstractAudioDeviceInfo_supportedCodecs(QAbstractAudioDeviceInfo* self) { QStringList _ret = self->supportedCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -95,7 +95,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractAudioDeviceInfo_supporte _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -103,12 +103,12 @@ struct miqt_array /* of struct miqt_string */ QAbstractAudioDeviceInfo_supporte struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedSampleRates(QAbstractAudioDeviceInfo* self) { QList _ret = self->supportedSampleRates(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -116,12 +116,12 @@ struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedSampleRates(QA struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedChannelCounts(QAbstractAudioDeviceInfo* self) { QList _ret = self->supportedChannelCounts(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -129,12 +129,12 @@ struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedChannelCounts( struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedSampleSizes(QAbstractAudioDeviceInfo* self) { QList _ret = self->supportedSampleSizes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -142,13 +142,13 @@ struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedSampleSizes(QA struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedByteOrders(QAbstractAudioDeviceInfo* self) { QList _ret = self->supportedByteOrders(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QAudioFormat::Endian _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -156,13 +156,13 @@ struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedByteOrders(QAb struct miqt_array /* of int */ QAbstractAudioDeviceInfo_supportedSampleTypes(QAbstractAudioDeviceInfo* self) { QList _ret = self->supportedSampleTypes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QAudioFormat::SampleType _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qaudiosystemplugin.cpp b/qt/multimedia/gen_qaudiosystemplugin.cpp index 92a8dccb4e..3d53dfa00e 100644 --- a/qt/multimedia/gen_qaudiosystemplugin.cpp +++ b/qt/multimedia/gen_qaudiosystemplugin.cpp @@ -39,8 +39,8 @@ void miqt_exec_callback_QAudioSystemPlugin_disconnectNotify(QAudioSystemPlugin*, struct miqt_array /* of struct miqt_string */ QAudioSystemFactoryInterface_availableDevices(const QAudioSystemFactoryInterface* self, int param1) { QList _ret = self->availableDevices(static_cast(param1)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -49,7 +49,7 @@ struct miqt_array /* of struct miqt_string */ QAudioSystemFactoryInterface_avai _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -341,8 +341,8 @@ struct miqt_string QAudioSystemPlugin_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QAudioSystemPlugin_availableDevices(const QAudioSystemPlugin* self, int param1) { QList _ret = self->availableDevices(static_cast(param1)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -351,7 +351,7 @@ struct miqt_array /* of struct miqt_string */ QAudioSystemPlugin_availableDevic _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcamera.cpp b/qt/multimedia/gen_qcamera.cpp index d881a46572..4720b545cf 100644 --- a/qt/multimedia/gen_qcamera.cpp +++ b/qt/multimedia/gen_qcamera.cpp @@ -348,8 +348,8 @@ struct miqt_string QCamera_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QCamera_availableDevices() { QList _ret = QCamera::availableDevices(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -358,7 +358,7 @@ struct miqt_array /* of struct miqt_string */ QCamera_availableDevices() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -434,12 +434,12 @@ void QCamera_setViewfinderSettings(QCamera* self, QCameraViewfinderSettings* set struct miqt_array /* of QCameraViewfinderSettings* */ QCamera_supportedViewfinderSettings(const QCamera* self) { QList _ret = self->supportedViewfinderSettings(); // Convert QList<> from C++ memory to manually-managed C memory - QCameraViewfinderSettings** _arr = static_cast(malloc(sizeof(QCameraViewfinderSettings*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraViewfinderSettings** _arr = static_cast(malloc(sizeof(QCameraViewfinderSettings*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraViewfinderSettings(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -447,12 +447,12 @@ struct miqt_array /* of QCameraViewfinderSettings* */ QCamera_supportedViewfind struct miqt_array /* of QSize* */ QCamera_supportedViewfinderResolutions(const QCamera* self) { QList _ret = self->supportedViewfinderResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -460,12 +460,12 @@ struct miqt_array /* of QSize* */ QCamera_supportedViewfinderResolutions(const struct miqt_array /* of QCamera__FrameRateRange* */ QCamera_supportedViewfinderFrameRateRanges(const QCamera* self) { QList _ret = self->supportedViewfinderFrameRateRanges(); // Convert QList<> from C++ memory to manually-managed C memory - QCamera__FrameRateRange** _arr = static_cast(malloc(sizeof(QCamera__FrameRateRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCamera__FrameRateRange** _arr = static_cast(malloc(sizeof(QCamera__FrameRateRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCamera::FrameRateRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -473,13 +473,13 @@ struct miqt_array /* of QCamera__FrameRateRange* */ QCamera_supportedViewfinder struct miqt_array /* of int */ QCamera_supportedViewfinderPixelFormats(const QCamera* self) { QList _ret = self->supportedViewfinderPixelFormats(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QVideoFrame::PixelFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -713,12 +713,12 @@ struct miqt_string QCamera_trUtf83(const char* s, const char* c, int n) { struct miqt_array /* of QCameraViewfinderSettings* */ QCamera_supportedViewfinderSettingsWithSettings(const QCamera* self, QCameraViewfinderSettings* settings) { QList _ret = self->supportedViewfinderSettings(*settings); // Convert QList<> from C++ memory to manually-managed C memory - QCameraViewfinderSettings** _arr = static_cast(malloc(sizeof(QCameraViewfinderSettings*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraViewfinderSettings** _arr = static_cast(malloc(sizeof(QCameraViewfinderSettings*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraViewfinderSettings(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -726,12 +726,12 @@ struct miqt_array /* of QCameraViewfinderSettings* */ QCamera_supportedViewfind struct miqt_array /* of QSize* */ QCamera_supportedViewfinderResolutionsWithSettings(const QCamera* self, QCameraViewfinderSettings* settings) { QList _ret = self->supportedViewfinderResolutions(*settings); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -739,12 +739,12 @@ struct miqt_array /* of QSize* */ QCamera_supportedViewfinderResolutionsWithSet struct miqt_array /* of QCamera__FrameRateRange* */ QCamera_supportedViewfinderFrameRateRangesWithSettings(const QCamera* self, QCameraViewfinderSettings* settings) { QList _ret = self->supportedViewfinderFrameRateRanges(*settings); // Convert QList<> from C++ memory to manually-managed C memory - QCamera__FrameRateRange** _arr = static_cast(malloc(sizeof(QCamera__FrameRateRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCamera__FrameRateRange** _arr = static_cast(malloc(sizeof(QCamera__FrameRateRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCamera::FrameRateRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -752,13 +752,13 @@ struct miqt_array /* of QCamera__FrameRateRange* */ QCamera_supportedViewfinder struct miqt_array /* of int */ QCamera_supportedViewfinderPixelFormatsWithSettings(const QCamera* self, QCameraViewfinderSettings* settings) { QList _ret = self->supportedViewfinderPixelFormats(*settings); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QVideoFrame::PixelFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcameracapturebufferformatcontrol.cpp b/qt/multimedia/gen_qcameracapturebufferformatcontrol.cpp index c80f234d25..9d25c74c9c 100644 --- a/qt/multimedia/gen_qcameracapturebufferformatcontrol.cpp +++ b/qt/multimedia/gen_qcameracapturebufferformatcontrol.cpp @@ -56,13 +56,13 @@ struct miqt_string QCameraCaptureBufferFormatControl_trUtf8(const char* s) { struct miqt_array /* of int */ QCameraCaptureBufferFormatControl_supportedBufferFormats(const QCameraCaptureBufferFormatControl* self) { QList _ret = self->supportedBufferFormats(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QVideoFrame::PixelFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcameraexposure.cpp b/qt/multimedia/gen_qcameraexposure.cpp index 5d3bbbe73f..55a69cbd2d 100644 --- a/qt/multimedia/gen_qcameraexposure.cpp +++ b/qt/multimedia/gen_qcameraexposure.cpp @@ -138,12 +138,12 @@ double QCameraExposure_requestedShutterSpeed(const QCameraExposure* self) { struct miqt_array /* of int */ QCameraExposure_supportedIsoSensitivities(const QCameraExposure* self) { QList _ret = self->supportedIsoSensitivities(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -151,12 +151,12 @@ struct miqt_array /* of int */ QCameraExposure_supportedIsoSensitivities(const struct miqt_array /* of double */ QCameraExposure_supportedApertures(const QCameraExposure* self) { QList _ret = self->supportedApertures(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -164,12 +164,12 @@ struct miqt_array /* of double */ QCameraExposure_supportedApertures(const QCam struct miqt_array /* of double */ QCameraExposure_supportedShutterSpeeds(const QCameraExposure* self) { QList _ret = self->supportedShutterSpeeds(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -339,12 +339,12 @@ struct miqt_string QCameraExposure_trUtf83(const char* s, const char* c, int n) struct miqt_array /* of int */ QCameraExposure_supportedIsoSensitivitiesWithContinuous(const QCameraExposure* self, bool* continuous) { QList _ret = self->supportedIsoSensitivities(continuous); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -352,12 +352,12 @@ struct miqt_array /* of int */ QCameraExposure_supportedIsoSensitivitiesWithCon struct miqt_array /* of double */ QCameraExposure_supportedAperturesWithContinuous(const QCameraExposure* self, bool* continuous) { QList _ret = self->supportedApertures(continuous); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -365,12 +365,12 @@ struct miqt_array /* of double */ QCameraExposure_supportedAperturesWithContinu struct miqt_array /* of double */ QCameraExposure_supportedShutterSpeedsWithContinuous(const QCameraExposure* self, bool* continuous) { QList _ret = self->supportedShutterSpeeds(continuous); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcameraexposurecontrol.cpp b/qt/multimedia/gen_qcameraexposurecontrol.cpp index 2cd4ae688f..478aa14eab 100644 --- a/qt/multimedia/gen_qcameraexposurecontrol.cpp +++ b/qt/multimedia/gen_qcameraexposurecontrol.cpp @@ -63,12 +63,12 @@ bool QCameraExposureControl_isParameterSupported(const QCameraExposureControl* s struct miqt_array /* of QVariant* */ QCameraExposureControl_supportedParameterRange(const QCameraExposureControl* self, int parameter, bool* continuous) { QVariantList _ret = self->supportedParameterRange(static_cast(parameter), continuous); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcamerafocus.cpp b/qt/multimedia/gen_qcamerafocus.cpp index de03dd6270..1c067c5989 100644 --- a/qt/multimedia/gen_qcamerafocus.cpp +++ b/qt/multimedia/gen_qcamerafocus.cpp @@ -149,12 +149,12 @@ void QCameraFocus_setCustomFocusPoint(QCameraFocus* self, QPointF* point) { struct miqt_array /* of QCameraFocusZone* */ QCameraFocus_focusZones(const QCameraFocus* self) { QCameraFocusZoneList _ret = self->focusZones(); // Convert QList<> from C++ memory to manually-managed C memory - QCameraFocusZone** _arr = static_cast(malloc(sizeof(QCameraFocusZone*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraFocusZone** _arr = static_cast(malloc(sizeof(QCameraFocusZone*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraFocusZone(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcamerafocuscontrol.cpp b/qt/multimedia/gen_qcamerafocuscontrol.cpp index a3a6457291..233b4b9e9a 100644 --- a/qt/multimedia/gen_qcamerafocuscontrol.cpp +++ b/qt/multimedia/gen_qcamerafocuscontrol.cpp @@ -95,12 +95,12 @@ void QCameraFocusControl_setCustomFocusPoint(QCameraFocusControl* self, QPointF* struct miqt_array /* of QCameraFocusZone* */ QCameraFocusControl_focusZones(const QCameraFocusControl* self) { QCameraFocusZoneList _ret = self->focusZones(); // Convert QList<> from C++ memory to manually-managed C memory - QCameraFocusZone** _arr = static_cast(malloc(sizeof(QCameraFocusZone*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraFocusZone** _arr = static_cast(malloc(sizeof(QCameraFocusZone*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraFocusZone(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcameraimagecapture.cpp b/qt/multimedia/gen_qcameraimagecapture.cpp index e7d2f93ce8..d593a1a8d8 100644 --- a/qt/multimedia/gen_qcameraimagecapture.cpp +++ b/qt/multimedia/gen_qcameraimagecapture.cpp @@ -292,8 +292,8 @@ bool QCameraImageCapture_isReadyForCapture(const QCameraImageCapture* self) { struct miqt_array /* of struct miqt_string */ QCameraImageCapture_supportedImageCodecs(const QCameraImageCapture* self) { QStringList _ret = self->supportedImageCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -304,7 +304,7 @@ struct miqt_array /* of struct miqt_string */ QCameraImageCapture_supportedImag _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -324,12 +324,12 @@ struct miqt_string QCameraImageCapture_imageCodecDescription(const QCameraImageC struct miqt_array /* of QSize* */ QCameraImageCapture_supportedResolutions(const QCameraImageCapture* self) { QList _ret = self->supportedResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -345,13 +345,13 @@ void QCameraImageCapture_setEncodingSettings(QCameraImageCapture* self, QImageEn struct miqt_array /* of int */ QCameraImageCapture_supportedBufferFormats(const QCameraImageCapture* self) { QList _ret = self->supportedBufferFormats(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QVideoFrame::PixelFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -572,12 +572,12 @@ struct miqt_string QCameraImageCapture_trUtf83(const char* s, const char* c, int struct miqt_array /* of QSize* */ QCameraImageCapture_supportedResolutionsWithSettings(const QCameraImageCapture* self, QImageEncoderSettings* settings) { QList _ret = self->supportedResolutions(*settings); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -585,12 +585,12 @@ struct miqt_array /* of QSize* */ QCameraImageCapture_supportedResolutionsWithS struct miqt_array /* of QSize* */ QCameraImageCapture_supportedResolutions2(const QCameraImageCapture* self, QImageEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedResolutions(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcamerainfo.cpp b/qt/multimedia/gen_qcamerainfo.cpp index 9562de3706..c1aec856ae 100644 --- a/qt/multimedia/gen_qcamerainfo.cpp +++ b/qt/multimedia/gen_qcamerainfo.cpp @@ -87,12 +87,12 @@ QCameraInfo* QCameraInfo_defaultCamera() { struct miqt_array /* of QCameraInfo* */ QCameraInfo_availableCameras() { QList _ret = QCameraInfo::availableCameras(); // Convert QList<> from C++ memory to manually-managed C memory - QCameraInfo** _arr = static_cast(malloc(sizeof(QCameraInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraInfo** _arr = static_cast(malloc(sizeof(QCameraInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -100,12 +100,12 @@ struct miqt_array /* of QCameraInfo* */ QCameraInfo_availableCameras() { struct miqt_array /* of QCameraInfo* */ QCameraInfo_availableCamerasWithPosition(int position) { QList _ret = QCameraInfo::availableCameras(static_cast(position)); // Convert QList<> from C++ memory to manually-managed C memory - QCameraInfo** _arr = static_cast(malloc(sizeof(QCameraInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraInfo** _arr = static_cast(malloc(sizeof(QCameraInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcameraviewfindersettingscontrol.cpp b/qt/multimedia/gen_qcameraviewfindersettingscontrol.cpp index 996751a2bd..d45e32a431 100644 --- a/qt/multimedia/gen_qcameraviewfindersettingscontrol.cpp +++ b/qt/multimedia/gen_qcameraviewfindersettingscontrol.cpp @@ -152,12 +152,12 @@ struct miqt_string QCameraViewfinderSettingsControl2_trUtf8(const char* s) { struct miqt_array /* of QCameraViewfinderSettings* */ QCameraViewfinderSettingsControl2_supportedViewfinderSettings(const QCameraViewfinderSettingsControl2* self) { QList _ret = self->supportedViewfinderSettings(); // Convert QList<> from C++ memory to manually-managed C memory - QCameraViewfinderSettings** _arr = static_cast(malloc(sizeof(QCameraViewfinderSettings*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraViewfinderSettings** _arr = static_cast(malloc(sizeof(QCameraViewfinderSettings*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraViewfinderSettings(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qcustomaudiorolecontrol.cpp b/qt/multimedia/gen_qcustomaudiorolecontrol.cpp index 097ba601b4..20fe16e87a 100644 --- a/qt/multimedia/gen_qcustomaudiorolecontrol.cpp +++ b/qt/multimedia/gen_qcustomaudiorolecontrol.cpp @@ -72,8 +72,8 @@ void QCustomAudioRoleControl_setCustomAudioRole(QCustomAudioRoleControl* self, s struct miqt_array /* of struct miqt_string */ QCustomAudioRoleControl_supportedCustomAudioRoles(const QCustomAudioRoleControl* self) { QStringList _ret = self->supportedCustomAudioRoles(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -84,7 +84,7 @@ struct miqt_array /* of struct miqt_string */ QCustomAudioRoleControl_supported _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qimageencodercontrol.cpp b/qt/multimedia/gen_qimageencodercontrol.cpp index a5fa65eb72..817f572dde 100644 --- a/qt/multimedia/gen_qimageencodercontrol.cpp +++ b/qt/multimedia/gen_qimageencodercontrol.cpp @@ -57,8 +57,8 @@ struct miqt_string QImageEncoderControl_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QImageEncoderControl_supportedImageCodecs(const QImageEncoderControl* self) { QStringList _ret = self->supportedImageCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -69,7 +69,7 @@ struct miqt_array /* of struct miqt_string */ QImageEncoderControl_supportedIma _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -89,12 +89,12 @@ struct miqt_string QImageEncoderControl_imageCodecDescription(const QImageEncode struct miqt_array /* of QSize* */ QImageEncoderControl_supportedResolutions(const QImageEncoderControl* self, QImageEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedResolutions(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmediacontainercontrol.cpp b/qt/multimedia/gen_qmediacontainercontrol.cpp index c2b5e00af5..aa7222a33c 100644 --- a/qt/multimedia/gen_qmediacontainercontrol.cpp +++ b/qt/multimedia/gen_qmediacontainercontrol.cpp @@ -55,8 +55,8 @@ struct miqt_string QMediaContainerControl_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QMediaContainerControl_supportedContainers(const QMediaContainerControl* self) { QStringList _ret = self->supportedContainers(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -67,7 +67,7 @@ struct miqt_array /* of struct miqt_string */ QMediaContainerControl_supportedC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmediacontent.cpp b/qt/multimedia/gen_qmediacontent.cpp index 426a14c0a2..87535a290c 100644 --- a/qt/multimedia/gen_qmediacontent.cpp +++ b/qt/multimedia/gen_qmediacontent.cpp @@ -32,13 +32,13 @@ QMediaContent* QMediaContent_new4(QMediaResource* contentResource) { } QMediaContent* QMediaContent_new5(struct miqt_array /* of QMediaResource* */ resources) { - QMediaResourceList resources_QList; - resources_QList.reserve(resources.len); + QMediaResourceList resources_QMediaResourceList; + resources_QMediaResourceList.reserve(resources.len); QMediaResource** resources_arr = static_cast(resources.data); for(size_t i = 0; i < resources.len; ++i) { - resources_QList.push_back(*(resources_arr[i])); + resources_QMediaResourceList.push_back(*(resources_arr[i])); } - return new (std::nothrow) QMediaContent(resources_QList); + return new (std::nothrow) QMediaContent(resources_QMediaResourceList); } QMediaContent* QMediaContent_new6(QMediaContent* other) { @@ -92,12 +92,12 @@ QMediaResource* QMediaContent_canonicalResource(const QMediaContent* self) { struct miqt_array /* of QMediaResource* */ QMediaContent_resources(const QMediaContent* self) { QMediaResourceList _ret = self->resources(); // Convert QList<> from C++ memory to manually-managed C memory - QMediaResource** _arr = static_cast(malloc(sizeof(QMediaResource*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMediaResource** _arr = static_cast(malloc(sizeof(QMediaResource*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMediaResource(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmediaobject.cpp b/qt/multimedia/gen_qmediaobject.cpp index be8ac816cc..df6cead3de 100644 --- a/qt/multimedia/gen_qmediaobject.cpp +++ b/qt/multimedia/gen_qmediaobject.cpp @@ -101,8 +101,8 @@ QVariant* QMediaObject_metaData(const QMediaObject* self, struct miqt_string key struct miqt_array /* of struct miqt_string */ QMediaObject_availableMetaData(const QMediaObject* self) { QStringList _ret = self->availableMetaData(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -113,7 +113,7 @@ struct miqt_array /* of struct miqt_string */ QMediaObject_availableMetaData(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmediaplayer.cpp b/qt/multimedia/gen_qmediaplayer.cpp index 4c0280c1a1..b949d8e766 100644 --- a/qt/multimedia/gen_qmediaplayer.cpp +++ b/qt/multimedia/gen_qmediaplayer.cpp @@ -333,8 +333,8 @@ int QMediaPlayer_hasSupport(struct miqt_string mimeType) { struct miqt_array /* of struct miqt_string */ QMediaPlayer_supportedMimeTypes() { QStringList _ret = QMediaPlayer::supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -345,7 +345,7 @@ struct miqt_array /* of struct miqt_string */ QMediaPlayer_supportedMimeTypes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -363,13 +363,13 @@ void QMediaPlayer_setVideoOutputWithSurface(QMediaPlayer* self, QAbstractVideoSu } void QMediaPlayer_setVideoOutputWithSurfaces(QMediaPlayer* self, struct miqt_array /* of QAbstractVideoSurface* */ surfaces) { - QVector surfaces_QList; - surfaces_QList.reserve(surfaces.len); + QVector surfaces_QVector; + surfaces_QVector.reserve(surfaces.len); QAbstractVideoSurface** surfaces_arr = static_cast(surfaces.data); for(size_t i = 0; i < surfaces.len; ++i) { - surfaces_QList.push_back(surfaces_arr[i]); + surfaces_QVector.push_back(surfaces_arr[i]); } - self->setVideoOutput(surfaces_QList); + self->setVideoOutput(surfaces_QVector); } QMediaContent* QMediaPlayer_media(const QMediaPlayer* self) { @@ -474,13 +474,13 @@ void QMediaPlayer_setAudioRole(QMediaPlayer* self, int audioRole) { struct miqt_array /* of int */ QMediaPlayer_supportedAudioRoles(const QMediaPlayer* self) { QList _ret = self->supportedAudioRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QAudio::Role _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -504,8 +504,8 @@ void QMediaPlayer_setCustomAudioRole(QMediaPlayer* self, struct miqt_string audi struct miqt_array /* of struct miqt_string */ QMediaPlayer_supportedCustomAudioRoles(const QMediaPlayer* self) { QStringList _ret = self->supportedCustomAudioRoles(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -516,7 +516,7 @@ struct miqt_array /* of struct miqt_string */ QMediaPlayer_supportedCustomAudio _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -829,35 +829,35 @@ struct miqt_string QMediaPlayer_trUtf83(const char* s, const char* c, int n) { int QMediaPlayer_hasSupport2(struct miqt_string mimeType, struct miqt_array /* of struct miqt_string */ codecs) { QString mimeType_QString = QString::fromUtf8(mimeType.data, mimeType.len); - QStringList codecs_QList; - codecs_QList.reserve(codecs.len); + QStringList codecs_QStringList; + codecs_QStringList.reserve(codecs.len); struct miqt_string* codecs_arr = static_cast(codecs.data); for(size_t i = 0; i < codecs.len; ++i) { QString codecs_arr_i_QString = QString::fromUtf8(codecs_arr[i].data, codecs_arr[i].len); - codecs_QList.push_back(codecs_arr_i_QString); + codecs_QStringList.push_back(codecs_arr_i_QString); } - QMultimedia::SupportEstimate _ret = QMediaPlayer::hasSupport(mimeType_QString, codecs_QList); + QMultimedia::SupportEstimate _ret = QMediaPlayer::hasSupport(mimeType_QString, codecs_QStringList); return static_cast(_ret); } int QMediaPlayer_hasSupport3(struct miqt_string mimeType, struct miqt_array /* of struct miqt_string */ codecs, int flags) { QString mimeType_QString = QString::fromUtf8(mimeType.data, mimeType.len); - QStringList codecs_QList; - codecs_QList.reserve(codecs.len); + QStringList codecs_QStringList; + codecs_QStringList.reserve(codecs.len); struct miqt_string* codecs_arr = static_cast(codecs.data); for(size_t i = 0; i < codecs.len; ++i) { QString codecs_arr_i_QString = QString::fromUtf8(codecs_arr[i].data, codecs_arr[i].len); - codecs_QList.push_back(codecs_arr_i_QString); + codecs_QStringList.push_back(codecs_arr_i_QString); } - QMultimedia::SupportEstimate _ret = QMediaPlayer::hasSupport(mimeType_QString, codecs_QList, static_cast(flags)); + QMultimedia::SupportEstimate _ret = QMediaPlayer::hasSupport(mimeType_QString, codecs_QStringList, static_cast(flags)); return static_cast(_ret); } struct miqt_array /* of struct miqt_string */ QMediaPlayer_supportedMimeTypesWithFlags(int flags) { QStringList _ret = QMediaPlayer::supportedMimeTypes(static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -868,7 +868,7 @@ struct miqt_array /* of struct miqt_string */ QMediaPlayer_supportedMimeTypesWi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmediarecorder.cpp b/qt/multimedia/gen_qmediarecorder.cpp index 8be19926a9..7c883d1143 100644 --- a/qt/multimedia/gen_qmediarecorder.cpp +++ b/qt/multimedia/gen_qmediarecorder.cpp @@ -328,8 +328,8 @@ double QMediaRecorder_volume(const QMediaRecorder* self) { struct miqt_array /* of struct miqt_string */ QMediaRecorder_supportedContainers(const QMediaRecorder* self) { QStringList _ret = self->supportedContainers(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -340,7 +340,7 @@ struct miqt_array /* of struct miqt_string */ QMediaRecorder_supportedContainer _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -360,8 +360,8 @@ struct miqt_string QMediaRecorder_containerDescription(const QMediaRecorder* sel struct miqt_array /* of struct miqt_string */ QMediaRecorder_supportedAudioCodecs(const QMediaRecorder* self) { QStringList _ret = self->supportedAudioCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -372,7 +372,7 @@ struct miqt_array /* of struct miqt_string */ QMediaRecorder_supportedAudioCode _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -392,12 +392,12 @@ struct miqt_string QMediaRecorder_audioCodecDescription(const QMediaRecorder* se struct miqt_array /* of int */ QMediaRecorder_supportedAudioSampleRates(const QMediaRecorder* self) { QList _ret = self->supportedAudioSampleRates(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -405,8 +405,8 @@ struct miqt_array /* of int */ QMediaRecorder_supportedAudioSampleRates(const Q struct miqt_array /* of struct miqt_string */ QMediaRecorder_supportedVideoCodecs(const QMediaRecorder* self) { QStringList _ret = self->supportedVideoCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -417,7 +417,7 @@ struct miqt_array /* of struct miqt_string */ QMediaRecorder_supportedVideoCode _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -437,12 +437,12 @@ struct miqt_string QMediaRecorder_videoCodecDescription(const QMediaRecorder* se struct miqt_array /* of QSize* */ QMediaRecorder_supportedResolutions(const QMediaRecorder* self) { QList _ret = self->supportedResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -450,12 +450,12 @@ struct miqt_array /* of QSize* */ QMediaRecorder_supportedResolutions(const QMe struct miqt_array /* of double */ QMediaRecorder_supportedFrameRates(const QMediaRecorder* self) { QList _ret = self->supportedFrameRates(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -517,8 +517,8 @@ void QMediaRecorder_setMetaData(QMediaRecorder* self, struct miqt_string key, QV struct miqt_array /* of struct miqt_string */ QMediaRecorder_availableMetaData(const QMediaRecorder* self) { QStringList _ret = self->availableMetaData(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -529,7 +529,7 @@ struct miqt_array /* of struct miqt_string */ QMediaRecorder_availableMetaData( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -762,12 +762,12 @@ struct miqt_string QMediaRecorder_trUtf83(const char* s, const char* c, int n) { struct miqt_array /* of int */ QMediaRecorder_supportedAudioSampleRatesWithSettings(const QMediaRecorder* self, QAudioEncoderSettings* settings) { QList _ret = self->supportedAudioSampleRates(*settings); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -775,12 +775,12 @@ struct miqt_array /* of int */ QMediaRecorder_supportedAudioSampleRatesWithSett struct miqt_array /* of int */ QMediaRecorder_supportedAudioSampleRates2(const QMediaRecorder* self, QAudioEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedAudioSampleRates(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -788,12 +788,12 @@ struct miqt_array /* of int */ QMediaRecorder_supportedAudioSampleRates2(const struct miqt_array /* of QSize* */ QMediaRecorder_supportedResolutionsWithSettings(const QMediaRecorder* self, QVideoEncoderSettings* settings) { QList _ret = self->supportedResolutions(*settings); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -801,12 +801,12 @@ struct miqt_array /* of QSize* */ QMediaRecorder_supportedResolutionsWithSettin struct miqt_array /* of QSize* */ QMediaRecorder_supportedResolutions2(const QMediaRecorder* self, QVideoEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedResolutions(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -814,12 +814,12 @@ struct miqt_array /* of QSize* */ QMediaRecorder_supportedResolutions2(const QM struct miqt_array /* of double */ QMediaRecorder_supportedFrameRatesWithSettings(const QMediaRecorder* self, QVideoEncoderSettings* settings) { QList _ret = self->supportedFrameRates(*settings); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -827,12 +827,12 @@ struct miqt_array /* of double */ QMediaRecorder_supportedFrameRatesWithSetting struct miqt_array /* of double */ QMediaRecorder_supportedFrameRates2(const QMediaRecorder* self, QVideoEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedFrameRates(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmediaserviceproviderplugin.cpp b/qt/multimedia/gen_qmediaserviceproviderplugin.cpp index 7ec8280d3a..83592b203e 100644 --- a/qt/multimedia/gen_qmediaserviceproviderplugin.cpp +++ b/qt/multimedia/gen_qmediaserviceproviderplugin.cpp @@ -32,14 +32,14 @@ QMediaServiceProviderHint* QMediaServiceProviderHint_new() { QMediaServiceProviderHint* QMediaServiceProviderHint_new2(struct miqt_string mimeType, struct miqt_array /* of struct miqt_string */ codecs) { QString mimeType_QString = QString::fromUtf8(mimeType.data, mimeType.len); - QStringList codecs_QList; - codecs_QList.reserve(codecs.len); + QStringList codecs_QStringList; + codecs_QStringList.reserve(codecs.len); struct miqt_string* codecs_arr = static_cast(codecs.data); for(size_t i = 0; i < codecs.len; ++i) { QString codecs_arr_i_QString = QString::fromUtf8(codecs_arr[i].data, codecs_arr[i].len); - codecs_QList.push_back(codecs_arr_i_QString); + codecs_QStringList.push_back(codecs_arr_i_QString); } - return new (std::nothrow) QMediaServiceProviderHint(mimeType_QString, codecs_QList); + return new (std::nothrow) QMediaServiceProviderHint(mimeType_QString, codecs_QStringList); } QMediaServiceProviderHint* QMediaServiceProviderHint_new3(struct miqt_string device) { @@ -94,8 +94,8 @@ struct miqt_string QMediaServiceProviderHint_mimeType(const QMediaServiceProvide struct miqt_array /* of struct miqt_string */ QMediaServiceProviderHint_codecs(const QMediaServiceProviderHint* self) { QStringList _ret = self->codecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -106,7 +106,7 @@ struct miqt_array /* of struct miqt_string */ QMediaServiceProviderHint_codecs( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -153,22 +153,22 @@ void QMediaServiceProviderFactoryInterface_delete(QMediaServiceProviderFactoryIn int QMediaServiceSupportedFormatsInterface_hasSupport(const QMediaServiceSupportedFormatsInterface* self, struct miqt_string mimeType, struct miqt_array /* of struct miqt_string */ codecs) { QString mimeType_QString = QString::fromUtf8(mimeType.data, mimeType.len); - QStringList codecs_QList; - codecs_QList.reserve(codecs.len); + QStringList codecs_QStringList; + codecs_QStringList.reserve(codecs.len); struct miqt_string* codecs_arr = static_cast(codecs.data); for(size_t i = 0; i < codecs.len; ++i) { QString codecs_arr_i_QString = QString::fromUtf8(codecs_arr[i].data, codecs_arr[i].len); - codecs_QList.push_back(codecs_arr_i_QString); + codecs_QStringList.push_back(codecs_arr_i_QString); } - QMultimedia::SupportEstimate _ret = self->hasSupport(mimeType_QString, codecs_QList); + QMultimedia::SupportEstimate _ret = self->hasSupport(mimeType_QString, codecs_QStringList); return static_cast(_ret); } struct miqt_array /* of struct miqt_string */ QMediaServiceSupportedFormatsInterface_supportedMimeTypes(const QMediaServiceSupportedFormatsInterface* self) { QStringList _ret = self->supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -179,7 +179,7 @@ struct miqt_array /* of struct miqt_string */ QMediaServiceSupportedFormatsInte _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -196,8 +196,8 @@ struct miqt_array /* of struct miqt_string */ QMediaServiceSupportedDevicesInte QByteArray service_QByteArray(service.data, service.len); QList _ret = self->devices(service_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -206,7 +206,7 @@ struct miqt_array /* of struct miqt_string */ QMediaServiceSupportedDevicesInte _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmediatimerange.cpp b/qt/multimedia/gen_qmediatimerange.cpp index b215e01cda..544a594dc2 100644 --- a/qt/multimedia/gen_qmediatimerange.cpp +++ b/qt/multimedia/gen_qmediatimerange.cpp @@ -95,12 +95,12 @@ long long QMediaTimeRange_latestTime(const QMediaTimeRange* self) { struct miqt_array /* of QMediaTimeInterval* */ QMediaTimeRange_intervals(const QMediaTimeRange* self) { QList _ret = self->intervals(); // Convert QList<> from C++ memory to manually-managed C memory - QMediaTimeInterval** _arr = static_cast(malloc(sizeof(QMediaTimeInterval*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMediaTimeInterval** _arr = static_cast(malloc(sizeof(QMediaTimeInterval*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMediaTimeInterval(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmetadatareadercontrol.cpp b/qt/multimedia/gen_qmetadatareadercontrol.cpp index ede7d55480..b17e963ffa 100644 --- a/qt/multimedia/gen_qmetadatareadercontrol.cpp +++ b/qt/multimedia/gen_qmetadatareadercontrol.cpp @@ -68,8 +68,8 @@ QVariant* QMetaDataReaderControl_metaData(const QMetaDataReaderControl* self, st struct miqt_array /* of struct miqt_string */ QMetaDataReaderControl_availableMetaData(const QMetaDataReaderControl* self) { QStringList _ret = self->availableMetaData(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -80,7 +80,7 @@ struct miqt_array /* of struct miqt_string */ QMetaDataReaderControl_availableM _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qmetadatawritercontrol.cpp b/qt/multimedia/gen_qmetadatawritercontrol.cpp index bfd8392649..d5b652f4c9 100644 --- a/qt/multimedia/gen_qmetadatawritercontrol.cpp +++ b/qt/multimedia/gen_qmetadatawritercontrol.cpp @@ -78,8 +78,8 @@ void QMetaDataWriterControl_setMetaData(QMetaDataWriterControl* self, struct miq struct miqt_array /* of struct miqt_string */ QMetaDataWriterControl_availableMetaData(const QMetaDataWriterControl* self) { QStringList _ret = self->availableMetaData(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -90,7 +90,7 @@ struct miqt_array /* of struct miqt_string */ QMetaDataWriterControl_availableM _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qsoundeffect.cpp b/qt/multimedia/gen_qsoundeffect.cpp index 5ef9bcab35..3a0e2416c5 100644 --- a/qt/multimedia/gen_qsoundeffect.cpp +++ b/qt/multimedia/gen_qsoundeffect.cpp @@ -230,8 +230,8 @@ struct miqt_string QSoundEffect_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QSoundEffect_supportedMimeTypes() { QStringList _ret = QSoundEffect::supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -242,7 +242,7 @@ struct miqt_array /* of struct miqt_string */ QSoundEffect_supportedMimeTypes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qvideoencodersettingscontrol.cpp b/qt/multimedia/gen_qvideoencodersettingscontrol.cpp index 35d70c0f3b..2ff19c8c25 100644 --- a/qt/multimedia/gen_qvideoencodersettingscontrol.cpp +++ b/qt/multimedia/gen_qvideoencodersettingscontrol.cpp @@ -57,12 +57,12 @@ struct miqt_string QVideoEncoderSettingsControl_trUtf8(const char* s) { struct miqt_array /* of QSize* */ QVideoEncoderSettingsControl_supportedResolutions(const QVideoEncoderSettingsControl* self, QVideoEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedResolutions(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -70,12 +70,12 @@ struct miqt_array /* of QSize* */ QVideoEncoderSettingsControl_supportedResolut struct miqt_array /* of double */ QVideoEncoderSettingsControl_supportedFrameRates(const QVideoEncoderSettingsControl* self, QVideoEncoderSettings* settings, bool* continuous) { QList _ret = self->supportedFrameRates(*settings, continuous); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -83,8 +83,8 @@ struct miqt_array /* of double */ QVideoEncoderSettingsControl_supportedFrameRa struct miqt_array /* of struct miqt_string */ QVideoEncoderSettingsControl_supportedVideoCodecs(const QVideoEncoderSettingsControl* self) { QStringList _ret = self->supportedVideoCodecs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -95,7 +95,7 @@ struct miqt_array /* of struct miqt_string */ QVideoEncoderSettingsControl_supp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/multimedia/gen_qvideosurfaceformat.cpp b/qt/multimedia/gen_qvideosurfaceformat.cpp index 3d9b2944dc..15ed82e8ba 100644 --- a/qt/multimedia/gen_qvideosurfaceformat.cpp +++ b/qt/multimedia/gen_qvideosurfaceformat.cpp @@ -139,8 +139,8 @@ QSize* QVideoSurfaceFormat_sizeHint(const QVideoSurfaceFormat* self) { struct miqt_array /* of struct miqt_string */ QVideoSurfaceFormat_propertyNames(const QVideoSurfaceFormat* self) { QList _ret = self->propertyNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -149,7 +149,7 @@ struct miqt_array /* of struct miqt_string */ QVideoSurfaceFormat_propertyNames _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/dtls/gen_qdtls.cpp b/qt/network/dtls/gen_qdtls.cpp index 1b118d0c1e..0c165c2b89 100644 --- a/qt/network/dtls/gen_qdtls.cpp +++ b/qt/network/dtls/gen_qdtls.cpp @@ -763,24 +763,24 @@ struct miqt_string QDtls_dtlsErrorString(const QDtls* self) { struct miqt_array /* of QSslError* */ QDtls_peerVerificationErrors(const QDtls* self) { QVector _ret = self->peerVerificationErrors(); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QDtls_ignoreVerificationErrors(QDtls* self, struct miqt_array /* of QSslError* */ errorsToIgnore) { - QVector errorsToIgnore_QList; - errorsToIgnore_QList.reserve(errorsToIgnore.len); + QVector errorsToIgnore_QVector; + errorsToIgnore_QVector.reserve(errorsToIgnore.len); QSslError** errorsToIgnore_arr = static_cast(errorsToIgnore.data); for(size_t i = 0; i < errorsToIgnore.len; ++i) { - errorsToIgnore_QList.push_back(*(errorsToIgnore_arr[i])); + errorsToIgnore_QVector.push_back(*(errorsToIgnore_arr[i])); } - self->ignoreVerificationErrors(errorsToIgnore_QList); + self->ignoreVerificationErrors(errorsToIgnore_QVector); } void QDtls_pskRequired(QDtls* self, QSslPreSharedKeyAuthenticator* authenticator) { diff --git a/qt/network/gen_qabstractnetworkcache.cpp b/qt/network/gen_qabstractnetworkcache.cpp index ba6d1c9767..34eeb38d4c 100644 --- a/qt/network/gen_qabstractnetworkcache.cpp +++ b/qt/network/gen_qabstractnetworkcache.cpp @@ -64,8 +64,8 @@ void QNetworkCacheMetaData_setUrl(QNetworkCacheMetaData* self, QUrl* url) { struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QNetworkCacheMetaData_rawHeaders(const QNetworkCacheMetaData* self) { QNetworkCacheMetaData::RawHeaderList _ret = self->rawHeaders(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -89,14 +89,14 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QNetworkCacheMetaData_setRawHeaders(QNetworkCacheMetaData* self, struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ headers) { - QNetworkCacheMetaData::RawHeaderList headers_QList; - headers_QList.reserve(headers.len); + QNetworkCacheMetaData::RawHeaderList headers_QNetworkCacheMetaData__RawHeaderList; + headers_QNetworkCacheMetaData__RawHeaderList.reserve(headers.len); struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * headers_arr = static_cast(headers.data); for(size_t i = 0; i < headers.len; ++i) { QPair headers_arr_i_QPair; @@ -106,9 +106,9 @@ void QNetworkCacheMetaData_setRawHeaders(QNetworkCacheMetaData* self, struct miq QByteArray headers_arr_i_second_arr_0_QByteArray(headers_arr_i_second_arr[0].data, headers_arr_i_second_arr[0].len); headers_arr_i_QPair.first = headers_arr_i_first_arr_0_QByteArray; headers_arr_i_QPair.second = headers_arr_i_second_arr_0_QByteArray; - headers_QList.push_back(headers_arr_i_QPair); + headers_QNetworkCacheMetaData__RawHeaderList.push_back(headers_arr_i_QPair); } - self->setRawHeaders(headers_QList); + self->setRawHeaders(headers_QNetworkCacheMetaData__RawHeaderList); } QDateTime* QNetworkCacheMetaData_lastModified(const QNetworkCacheMetaData* self) { diff --git a/qt/network/gen_qdnslookup.cpp b/qt/network/gen_qdnslookup.cpp index 90de28d55d..6dbb68f896 100644 --- a/qt/network/gen_qdnslookup.cpp +++ b/qt/network/gen_qdnslookup.cpp @@ -274,8 +274,8 @@ unsigned int QDnsTextRecord_timeToLive(const QDnsTextRecord* self) { struct miqt_array /* of struct miqt_string */ QDnsTextRecord_values(const QDnsTextRecord* self) { QList _ret = self->values(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -284,7 +284,7 @@ struct miqt_array /* of struct miqt_string */ QDnsTextRecord_values(const QDnsT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -552,12 +552,12 @@ void QDnsLookup_setNameserver(QDnsLookup* self, QHostAddress* nameserver) { struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_canonicalNameRecords(const QDnsLookup* self) { QList _ret = self->canonicalNameRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsDomainNameRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -565,12 +565,12 @@ struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_canonicalNameRecord struct miqt_array /* of QDnsHostAddressRecord* */ QDnsLookup_hostAddressRecords(const QDnsLookup* self) { QList _ret = self->hostAddressRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsHostAddressRecord** _arr = static_cast(malloc(sizeof(QDnsHostAddressRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsHostAddressRecord** _arr = static_cast(malloc(sizeof(QDnsHostAddressRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsHostAddressRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -578,12 +578,12 @@ struct miqt_array /* of QDnsHostAddressRecord* */ QDnsLookup_hostAddressRecords struct miqt_array /* of QDnsMailExchangeRecord* */ QDnsLookup_mailExchangeRecords(const QDnsLookup* self) { QList _ret = self->mailExchangeRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsMailExchangeRecord** _arr = static_cast(malloc(sizeof(QDnsMailExchangeRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsMailExchangeRecord** _arr = static_cast(malloc(sizeof(QDnsMailExchangeRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsMailExchangeRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -591,12 +591,12 @@ struct miqt_array /* of QDnsMailExchangeRecord* */ QDnsLookup_mailExchangeRecor struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_nameServerRecords(const QDnsLookup* self) { QList _ret = self->nameServerRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsDomainNameRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -604,12 +604,12 @@ struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_nameServerRecords(c struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_pointerRecords(const QDnsLookup* self) { QList _ret = self->pointerRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsDomainNameRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -617,12 +617,12 @@ struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_pointerRecords(cons struct miqt_array /* of QDnsServiceRecord* */ QDnsLookup_serviceRecords(const QDnsLookup* self) { QList _ret = self->serviceRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsServiceRecord** _arr = static_cast(malloc(sizeof(QDnsServiceRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsServiceRecord** _arr = static_cast(malloc(sizeof(QDnsServiceRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsServiceRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -630,12 +630,12 @@ struct miqt_array /* of QDnsServiceRecord* */ QDnsLookup_serviceRecords(const Q struct miqt_array /* of QDnsTextRecord* */ QDnsLookup_textRecords(const QDnsLookup* self) { QList _ret = self->textRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsTextRecord** _arr = static_cast(malloc(sizeof(QDnsTextRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsTextRecord** _arr = static_cast(malloc(sizeof(QDnsTextRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsTextRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qhostinfo.cpp b/qt/network/gen_qhostinfo.cpp index bfd0930ea5..9ce52b320d 100644 --- a/qt/network/gen_qhostinfo.cpp +++ b/qt/network/gen_qhostinfo.cpp @@ -54,12 +54,12 @@ void QHostInfo_setHostName(QHostInfo* self, struct miqt_string name) { struct miqt_array /* of QHostAddress* */ QHostInfo_addresses(const QHostInfo* self) { QList _ret = self->addresses(); // Convert QList<> from C++ memory to manually-managed C memory - QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QHostAddress(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkaccessmanager.cpp b/qt/network/gen_qnetworkaccessmanager.cpp index d3551b868c..691c74015a 100644 --- a/qt/network/gen_qnetworkaccessmanager.cpp +++ b/qt/network/gen_qnetworkaccessmanager.cpp @@ -256,8 +256,8 @@ struct miqt_string QNetworkAccessManager_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_supportedSchemes(const QNetworkAccessManager* self) { QStringList _ret = self->supportedSchemes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -268,7 +268,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_supportedSc _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -330,24 +330,24 @@ bool QNetworkAccessManager_isStrictTransportSecurityStoreEnabled(const QNetworkA } void QNetworkAccessManager_addStrictTransportSecurityHosts(QNetworkAccessManager* self, struct miqt_array /* of QHstsPolicy* */ knownHosts) { - QVector knownHosts_QList; - knownHosts_QList.reserve(knownHosts.len); + QVector knownHosts_QVector; + knownHosts_QVector.reserve(knownHosts.len); QHstsPolicy** knownHosts_arr = static_cast(knownHosts.data); for(size_t i = 0; i < knownHosts.len; ++i) { - knownHosts_QList.push_back(*(knownHosts_arr[i])); + knownHosts_QVector.push_back(*(knownHosts_arr[i])); } - self->addStrictTransportSecurityHosts(knownHosts_QList); + self->addStrictTransportSecurityHosts(knownHosts_QVector); } struct miqt_array /* of QHstsPolicy* */ QNetworkAccessManager_strictTransportSecurityHosts(const QNetworkAccessManager* self) { QVector _ret = self->strictTransportSecurityHosts(); // Convert QList<> from C++ memory to manually-managed C memory - QHstsPolicy** _arr = static_cast(malloc(sizeof(QHstsPolicy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QHstsPolicy** _arr = static_cast(malloc(sizeof(QHstsPolicy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QHstsPolicy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -531,12 +531,12 @@ void QNetworkAccessManager_connect_sslErrors(QNetworkAccessManager* self, intptr QNetworkReply* sigval1 = reply; const QList& errors_ret = errors; // Convert QList<> from C++ memory to manually-managed C memory - QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.size())); + for (size_t i = 0, e = errors_ret.size(); i < e; ++i) { errors_arr[i] = new QSslError(errors_ret[i]); } struct miqt_array errors_out; - errors_out.len = errors_ret.length(); + errors_out.len = errors_ret.size(); errors_out.data = static_cast(errors_arr); struct miqt_array /* of QSslError* */ sigval2 = errors_out; miqt_exec_callback_QNetworkAccessManager_sslErrors(slot, sigval1, sigval2); @@ -772,8 +772,8 @@ struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_protectedba *_dynamic_cast_ok = true; QStringList _ret = self_cast->supportedSchemesImplementation(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -784,7 +784,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_protectedba _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkconfigmanager.cpp b/qt/network/gen_qnetworkconfigmanager.cpp index 8f2efdd41e..bd2d46d51d 100644 --- a/qt/network/gen_qnetworkconfigmanager.cpp +++ b/qt/network/gen_qnetworkconfigmanager.cpp @@ -224,12 +224,12 @@ QNetworkConfiguration* QNetworkConfigurationManager_defaultConfiguration(const Q struct miqt_array /* of QNetworkConfiguration* */ QNetworkConfigurationManager_allConfigurations(const QNetworkConfigurationManager* self) { QList _ret = self->allConfigurations(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkConfiguration** _arr = static_cast(malloc(sizeof(QNetworkConfiguration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkConfiguration** _arr = static_cast(malloc(sizeof(QNetworkConfiguration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkConfiguration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -354,12 +354,12 @@ struct miqt_string QNetworkConfigurationManager_trUtf83(const char* s, const cha struct miqt_array /* of QNetworkConfiguration* */ QNetworkConfigurationManager_allConfigurationsWithFlags(const QNetworkConfigurationManager* self, int flags) { QList _ret = self->allConfigurations(static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkConfiguration** _arr = static_cast(malloc(sizeof(QNetworkConfiguration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkConfiguration** _arr = static_cast(malloc(sizeof(QNetworkConfiguration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkConfiguration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkconfiguration.cpp b/qt/network/gen_qnetworkconfiguration.cpp index 29f88974fb..1c7d7f1796 100644 --- a/qt/network/gen_qnetworkconfiguration.cpp +++ b/qt/network/gen_qnetworkconfiguration.cpp @@ -92,12 +92,12 @@ bool QNetworkConfiguration_isRoamingAvailable(const QNetworkConfiguration* self) struct miqt_array /* of QNetworkConfiguration* */ QNetworkConfiguration_children(const QNetworkConfiguration* self) { QList _ret = self->children(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkConfiguration** _arr = static_cast(malloc(sizeof(QNetworkConfiguration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkConfiguration** _arr = static_cast(malloc(sizeof(QNetworkConfiguration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkConfiguration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkcookie.cpp b/qt/network/gen_qnetworkcookie.cpp index 410a5b987c..9474c9028b 100644 --- a/qt/network/gen_qnetworkcookie.cpp +++ b/qt/network/gen_qnetworkcookie.cpp @@ -161,12 +161,12 @@ struct miqt_array /* of QNetworkCookie* */ QNetworkCookie_parseCookies(struct m QByteArray cookieString_QByteArray(cookieString.data, cookieString.len); QList _ret = QNetworkCookie::parseCookies(cookieString_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkcookiejar.cpp b/qt/network/gen_qnetworkcookiejar.cpp index be56c9322a..fab984b38b 100644 --- a/qt/network/gen_qnetworkcookiejar.cpp +++ b/qt/network/gen_qnetworkcookiejar.cpp @@ -78,12 +78,12 @@ class MiqtVirtualQNetworkCookieJar final : public QNetworkCookieJar { const QList& cookieList_ret = cookieList; // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** cookieList_arr = static_cast(malloc(sizeof(QNetworkCookie*) * cookieList_ret.length())); - for (size_t i = 0, e = cookieList_ret.length(); i < e; ++i) { + QNetworkCookie** cookieList_arr = static_cast(malloc(sizeof(QNetworkCookie*) * cookieList_ret.size())); + for (size_t i = 0, e = cookieList_ret.size(); i < e; ++i) { cookieList_arr[i] = new QNetworkCookie(cookieList_ret[i]); } struct miqt_array cookieList_out; - cookieList_out.len = cookieList_ret.length(); + cookieList_out.len = cookieList_ret.size(); cookieList_out.data = static_cast(cookieList_arr); struct miqt_array /* of QNetworkCookie* */ sigval1 = cookieList_out; const QUrl& url_ret = url; @@ -346,12 +346,12 @@ struct miqt_string QNetworkCookieJar_trUtf8(const char* s) { struct miqt_array /* of QNetworkCookie* */ QNetworkCookieJar_cookiesForUrl(const QNetworkCookieJar* self, QUrl* url) { QList _ret = self->cookiesForUrl(*url); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -435,12 +435,12 @@ bool QNetworkCookieJar_override_virtual_cookiesForUrl(void* self, intptr_t slot) struct miqt_array /* of QNetworkCookie* */ QNetworkCookieJar_virtualbase_cookiesForUrl(const void* self, QUrl* url) { QList _ret = static_cast(self)->QNetworkCookieJar::cookiesForUrl(*url); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -629,12 +629,12 @@ struct miqt_array /* of QNetworkCookie* */ QNetworkCookieJar_protectedbase_allC *_dynamic_cast_ok = true; QList _ret = self_cast->allCookies(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkinterface.cpp b/qt/network/gen_qnetworkinterface.cpp index 422ae01a5f..ae62a59342 100644 --- a/qt/network/gen_qnetworkinterface.cpp +++ b/qt/network/gen_qnetworkinterface.cpp @@ -188,12 +188,12 @@ struct miqt_string QNetworkInterface_hardwareAddress(const QNetworkInterface* se struct miqt_array /* of QNetworkAddressEntry* */ QNetworkInterface_addressEntries(const QNetworkInterface* self) { QList _ret = self->addressEntries(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkAddressEntry** _arr = static_cast(malloc(sizeof(QNetworkAddressEntry*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkAddressEntry** _arr = static_cast(malloc(sizeof(QNetworkAddressEntry*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkAddressEntry(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -226,12 +226,12 @@ struct miqt_string QNetworkInterface_interfaceNameFromIndex(int index) { struct miqt_array /* of QNetworkInterface* */ QNetworkInterface_allInterfaces() { QList _ret = QNetworkInterface::allInterfaces(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkInterface** _arr = static_cast(malloc(sizeof(QNetworkInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkInterface** _arr = static_cast(malloc(sizeof(QNetworkInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkInterface(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -239,12 +239,12 @@ struct miqt_array /* of QNetworkInterface* */ QNetworkInterface_allInterfaces() struct miqt_array /* of QHostAddress* */ QNetworkInterface_allAddresses() { QList _ret = QNetworkInterface::allAddresses(); // Convert QList<> from C++ memory to manually-managed C memory - QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QHostAddress(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkproxy.cpp b/qt/network/gen_qnetworkproxy.cpp index b1a4496fc8..59546fb86c 100644 --- a/qt/network/gen_qnetworkproxy.cpp +++ b/qt/network/gen_qnetworkproxy.cpp @@ -358,8 +358,8 @@ bool QNetworkProxy_hasRawHeader(const QNetworkProxy* self, struct miqt_string he struct miqt_array /* of struct miqt_string */ QNetworkProxy_rawHeaderList(const QNetworkProxy* self) { QList _ret = self->rawHeaderList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -368,7 +368,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkProxy_rawHeaderList(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -431,12 +431,12 @@ QNetworkProxyFactory* QNetworkProxyFactory_new() { struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_queryProxy(QNetworkProxyFactory* self, QNetworkProxyQuery* query) { QList _ret = self->queryProxy(*query); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -456,12 +456,12 @@ void QNetworkProxyFactory_setApplicationProxyFactory(QNetworkProxyFactory* facto struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_proxyForQuery(QNetworkProxyQuery* query) { QList _ret = QNetworkProxyFactory::proxyForQuery(*query); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -469,12 +469,12 @@ struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_proxyForQuery(QN struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_systemProxyForQuery() { QList _ret = QNetworkProxyFactory::systemProxyForQuery(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -486,12 +486,12 @@ void QNetworkProxyFactory_operatorAssign(QNetworkProxyFactory* self, QNetworkPro struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_systemProxyForQueryWithQuery(QNetworkProxyQuery* query) { QList _ret = QNetworkProxyFactory::systemProxyForQuery(*query); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qnetworkreply.cpp b/qt/network/gen_qnetworkreply.cpp index 6df76991e4..c069039e53 100644 --- a/qt/network/gen_qnetworkreply.cpp +++ b/qt/network/gen_qnetworkreply.cpp @@ -131,8 +131,8 @@ bool QNetworkReply_hasRawHeader(const QNetworkReply* self, struct miqt_string he struct miqt_array /* of struct miqt_string */ QNetworkReply_rawHeaderList(const QNetworkReply* self) { QList _ret = self->rawHeaderList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -141,7 +141,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkReply_rawHeaderList(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -159,8 +159,8 @@ struct miqt_string QNetworkReply_rawHeader(const QNetworkReply* self, struct miq struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QNetworkReply_rawHeaderPairs(const QNetworkReply* self) { const QList& _ret = self->rawHeaderPairs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -184,7 +184,7 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -287,12 +287,12 @@ void QNetworkReply_connect_sslErrors(QNetworkReply* self, intptr_t slot) { QNetworkReply::connect(self, static_cast&)>(&QNetworkReply::sslErrors), self, [=](const QList& errors) { const QList& errors_ret = errors; // Convert QList<> from C++ memory to manually-managed C memory - QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.size())); + for (size_t i = 0, e = errors_ret.size(); i < e; ++i) { errors_arr[i] = new QSslError(errors_ret[i]); } struct miqt_array errors_out; - errors_out.len = errors_ret.length(); + errors_out.len = errors_ret.size(); errors_out.data = static_cast(errors_arr); struct miqt_array /* of QSslError* */ sigval1 = errors_out; miqt_exec_callback_QNetworkReply_sslErrors(slot, sigval1); diff --git a/qt/network/gen_qnetworkrequest.cpp b/qt/network/gen_qnetworkrequest.cpp index 74534be4d8..4ac5a8747f 100644 --- a/qt/network/gen_qnetworkrequest.cpp +++ b/qt/network/gen_qnetworkrequest.cpp @@ -72,8 +72,8 @@ bool QNetworkRequest_hasRawHeader(const QNetworkRequest* self, struct miqt_strin struct miqt_array /* of struct miqt_string */ QNetworkRequest_rawHeaderList(const QNetworkRequest* self) { QList _ret = self->rawHeaderList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -82,7 +82,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkRequest_rawHeaderList(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qsslcertificate.cpp b/qt/network/gen_qsslcertificate.cpp index 21861f128c..53c64d0616 100644 --- a/qt/network/gen_qsslcertificate.cpp +++ b/qt/network/gen_qsslcertificate.cpp @@ -108,8 +108,8 @@ struct miqt_string QSslCertificate_digest(const QSslCertificate* self) { struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfo(const QSslCertificate* self, int info) { QStringList _ret = self->issuerInfo(static_cast(info)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -120,7 +120,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfo(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -129,8 +129,8 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoWithAtt QByteArray attribute_QByteArray(attribute.data, attribute.len); QStringList _ret = self->issuerInfo(attribute_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -141,7 +141,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoWithAtt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -149,8 +149,8 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoWithAtt struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfo(const QSslCertificate* self, int info) { QStringList _ret = self->subjectInfo(static_cast(info)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -161,7 +161,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfo(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -170,8 +170,8 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoWithAt QByteArray attribute_QByteArray(attribute.data, attribute.len); QStringList _ret = self->subjectInfo(attribute_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -182,7 +182,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoWithAt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -212,8 +212,8 @@ struct miqt_string QSslCertificate_subjectDisplayName(const QSslCertificate* sel struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoAttributes(const QSslCertificate* self) { QList _ret = self->subjectInfoAttributes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -222,7 +222,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoAttrib _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -230,8 +230,8 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoAttrib struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoAttributes(const QSslCertificate* self) { QList _ret = self->issuerInfoAttributes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -240,7 +240,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoAttribu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -260,12 +260,12 @@ QSslKey* QSslCertificate_publicKey(const QSslCertificate* self) { struct miqt_array /* of QSslCertificateExtension* */ QSslCertificate_extensions(const QSslCertificate* self) { QList _ret = self->extensions(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificateExtension** _arr = static_cast(malloc(sizeof(QSslCertificateExtension*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificateExtension** _arr = static_cast(malloc(sizeof(QSslCertificateExtension*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificateExtension(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -303,12 +303,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath(struct miq QString path_QString = QString::fromUtf8(path.data, path.len); QList _ret = QSslCertificate::fromPath(path_QString, static_cast(format), static_cast(syntax)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -317,12 +317,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPathWithPath(st QString path_QString = QString::fromUtf8(path.data, path.len); QList _ret = QSslCertificate::fromPath(path_QString); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -330,12 +330,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPathWithPath(st struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromDevice(QIODevice* device) { QList _ret = QSslCertificate::fromDevice(device); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -344,12 +344,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromData(struct miq QByteArray data_QByteArray(data.data, data.len); QList _ret = QSslCertificate::fromData(data_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -363,12 +363,12 @@ struct miqt_array /* of QSslError* */ QSslCertificate_verify(struct miqt_array } QList _ret = QSslCertificate::verify(certificateChain_QList); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -395,12 +395,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath2(struct mi QString path_QString = QString::fromUtf8(path.data, path.len); QList _ret = QSslCertificate::fromPath(path_QString, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -409,12 +409,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath3(struct mi QString path_QString = QString::fromUtf8(path.data, path.len); QList _ret = QSslCertificate::fromPath(path_QString, static_cast(format), static_cast(syntax)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -422,12 +422,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath3(struct mi struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromDevice2(QIODevice* device, int format) { QList _ret = QSslCertificate::fromDevice(device, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -436,12 +436,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromData2(struct mi QByteArray data_QByteArray(data.data, data.len); QList _ret = QSslCertificate::fromData(data_QByteArray, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -456,12 +456,12 @@ struct miqt_array /* of QSslError* */ QSslCertificate_verify2(struct miqt_array QString hostName_QString = QString::fromUtf8(hostName.data, hostName.len); QList _ret = QSslCertificate::verify(certificateChain_QList, hostName_QString); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qsslconfiguration.cpp b/qt/network/gen_qsslconfiguration.cpp index 5d9326b550..20820a58a7 100644 --- a/qt/network/gen_qsslconfiguration.cpp +++ b/qt/network/gen_qsslconfiguration.cpp @@ -79,12 +79,12 @@ void QSslConfiguration_setPeerVerifyDepth(QSslConfiguration* self, int depth) { struct miqt_array /* of QSslCertificate* */ QSslConfiguration_localCertificateChain(const QSslConfiguration* self) { QList _ret = self->localCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -114,12 +114,12 @@ QSslCertificate* QSslConfiguration_peerCertificate(const QSslConfiguration* self struct miqt_array /* of QSslCertificate* */ QSslConfiguration_peerCertificateChain(const QSslConfiguration* self) { QList _ret = self->peerCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -144,12 +144,12 @@ void QSslConfiguration_setPrivateKey(QSslConfiguration* self, QSslKey* key) { struct miqt_array /* of QSslCipher* */ QSslConfiguration_ciphers(const QSslConfiguration* self) { QList _ret = self->ciphers(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCipher(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -167,12 +167,12 @@ void QSslConfiguration_setCiphers(QSslConfiguration* self, struct miqt_array /* struct miqt_array /* of QSslCipher* */ QSslConfiguration_supportedCiphers() { QList _ret = QSslConfiguration::supportedCiphers(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCipher(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -180,12 +180,12 @@ struct miqt_array /* of QSslCipher* */ QSslConfiguration_supportedCiphers() { struct miqt_array /* of QSslCertificate* */ QSslConfiguration_caCertificates(const QSslConfiguration* self) { QList _ret = self->caCertificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -222,12 +222,12 @@ void QSslConfiguration_addCaCertificatesWithCertificates(QSslConfiguration* self struct miqt_array /* of QSslCertificate* */ QSslConfiguration_systemCaCertificates() { QList _ret = QSslConfiguration::systemCaCertificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -265,35 +265,35 @@ QSslKey* QSslConfiguration_ephemeralServerKey(const QSslConfiguration* self) { struct miqt_array /* of QSslEllipticCurve* */ QSslConfiguration_ellipticCurves(const QSslConfiguration* self) { QVector _ret = self->ellipticCurves(); // Convert QList<> from C++ memory to manually-managed C memory - QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslEllipticCurve(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QSslConfiguration_setEllipticCurves(QSslConfiguration* self, struct miqt_array /* of QSslEllipticCurve* */ curves) { - QVector curves_QList; - curves_QList.reserve(curves.len); + QVector curves_QVector; + curves_QVector.reserve(curves.len); QSslEllipticCurve** curves_arr = static_cast(curves.data); for(size_t i = 0; i < curves.len; ++i) { - curves_QList.push_back(*(curves_arr[i])); + curves_QVector.push_back(*(curves_arr[i])); } - self->setEllipticCurves(curves_QList); + self->setEllipticCurves(curves_QVector); } struct miqt_array /* of QSslEllipticCurve* */ QSslConfiguration_supportedEllipticCurves() { QVector _ret = QSslConfiguration::supportedEllipticCurves(); // Convert QList<> from C++ memory to manually-managed C memory - QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslEllipticCurve(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -393,8 +393,8 @@ void QSslConfiguration_setAllowedNextProtocols(QSslConfiguration* self, struct m struct miqt_array /* of struct miqt_string */ QSslConfiguration_allowedNextProtocols(const QSslConfiguration* self) { QList _ret = self->allowedNextProtocols(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -403,7 +403,7 @@ struct miqt_array /* of struct miqt_string */ QSslConfiguration_allowedNextProt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/network/gen_qsslsocket.cpp b/qt/network/gen_qsslsocket.cpp index 0424ca8942..c2ab155c1d 100644 --- a/qt/network/gen_qsslsocket.cpp +++ b/qt/network/gen_qsslsocket.cpp @@ -856,12 +856,12 @@ void QSslSocket_setLocalCertificateChain(QSslSocket* self, struct miqt_array /* struct miqt_array /* of QSslCertificate* */ QSslSocket_localCertificateChain(const QSslSocket* self) { QList _ret = self->localCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -886,12 +886,12 @@ QSslCertificate* QSslSocket_peerCertificate(const QSslSocket* self) { struct miqt_array /* of QSslCertificate* */ QSslSocket_peerCertificateChain(const QSslSocket* self) { QList _ret = self->peerCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -908,12 +908,12 @@ int QSslSocket_sessionProtocol(const QSslSocket* self) { struct miqt_array /* of QOcspResponse* */ QSslSocket_ocspResponses(const QSslSocket* self) { QVector _ret = self->ocspResponses(); // Convert QList<> from C++ memory to manually-managed C memory - QOcspResponse** _arr = static_cast(malloc(sizeof(QOcspResponse*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QOcspResponse** _arr = static_cast(malloc(sizeof(QOcspResponse*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QOcspResponse(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -934,12 +934,12 @@ QSslKey* QSslSocket_privateKey(const QSslSocket* self) { struct miqt_array /* of QSslCipher* */ QSslSocket_ciphers(const QSslSocket* self) { QList _ret = self->ciphers(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCipher(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -972,12 +972,12 @@ void QSslSocket_setDefaultCiphers(struct miqt_array /* of QSslCipher* */ cipher struct miqt_array /* of QSslCipher* */ QSslSocket_defaultCiphers() { QList _ret = QSslSocket::defaultCiphers(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCipher(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -985,12 +985,12 @@ struct miqt_array /* of QSslCipher* */ QSslSocket_defaultCiphers() { struct miqt_array /* of QSslCipher* */ QSslSocket_supportedCiphers() { QList _ret = QSslSocket::supportedCiphers(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCipher(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1027,12 +1027,12 @@ void QSslSocket_setCaCertificates(QSslSocket* self, struct miqt_array /* of QSsl struct miqt_array /* of QSslCertificate* */ QSslSocket_caCertificates(const QSslSocket* self) { QList _ret = self->caCertificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1069,12 +1069,12 @@ void QSslSocket_setDefaultCaCertificates(struct miqt_array /* of QSslCertificate struct miqt_array /* of QSslCertificate* */ QSslSocket_defaultCaCertificates() { QList _ret = QSslSocket::defaultCaCertificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1082,12 +1082,12 @@ struct miqt_array /* of QSslCertificate* */ QSslSocket_defaultCaCertificates() struct miqt_array /* of QSslCertificate* */ QSslSocket_systemCaCertificates() { QList _ret = QSslSocket::systemCaCertificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1115,12 +1115,12 @@ bool QSslSocket_waitForDisconnected(QSslSocket* self, int msecs) { struct miqt_array /* of QSslError* */ QSslSocket_sslErrors(const QSslSocket* self) { QList _ret = self->sslErrors(); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1128,12 +1128,12 @@ struct miqt_array /* of QSslError* */ QSslSocket_sslErrors(const QSslSocket* se struct miqt_array /* of QSslError* */ QSslSocket_sslHandshakeErrors(const QSslSocket* self) { QList _ret = self->sslHandshakeErrors(); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1231,12 +1231,12 @@ void QSslSocket_connect_sslErrorsWithErrors(QSslSocket* self, intptr_t slot) { QSslSocket::connect(self, static_cast&)>(&QSslSocket::sslErrors), self, [=](const QList& errors) { const QList& errors_ret = errors; // Convert QList<> from C++ memory to manually-managed C memory - QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.size())); + for (size_t i = 0, e = errors_ret.size(); i < e; ++i) { errors_arr[i] = new QSslError(errors_ret[i]); } struct miqt_array errors_out; - errors_out.len = errors_ret.length(); + errors_out.len = errors_ret.size(); errors_out.data = static_cast(errors_arr); struct miqt_array /* of QSslError* */ sigval1 = errors_out; miqt_exec_callback_QSslSocket_sslErrorsWithErrors(slot, sigval1); diff --git a/qt/pdf/gen_qpdfbookmarkmodel.cpp b/qt/pdf/gen_qpdfbookmarkmodel.cpp index 0f82d45356..51a36ad12d 100644 --- a/qt/pdf/gen_qpdfbookmarkmodel.cpp +++ b/qt/pdf/gen_qpdfbookmarkmodel.cpp @@ -365,14 +365,14 @@ class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self); @@ -388,12 +388,12 @@ class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeData(this, handle__mimeData, sigval1); @@ -718,13 +718,13 @@ class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -1331,8 +1331,8 @@ bool QPdfBookmarkModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QPdfBookmarkModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1343,7 +1343,7 @@ struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mim _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1359,13 +1359,13 @@ bool QPdfBookmarkModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QPdfBookmarkModel::mimeData(indexes_QList); + return static_cast(self)->QPdfBookmarkModel::mimeData(indexes_QModelIndexList); } bool QPdfBookmarkModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -1594,12 +1594,12 @@ bool QPdfBookmarkModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QPdfBookmarkModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1774,13 +1774,13 @@ void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const vo } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QPdfBookmarkModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -1967,19 +1967,19 @@ void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_ca } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -1992,12 +1992,12 @@ struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persist *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/pdf/gen_qpdfsearchmodel.cpp b/qt/pdf/gen_qpdfsearchmodel.cpp index 5506e84bea..b80d4288be 100644 --- a/qt/pdf/gen_qpdfsearchmodel.cpp +++ b/qt/pdf/gen_qpdfsearchmodel.cpp @@ -369,14 +369,14 @@ class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self); @@ -392,12 +392,12 @@ class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { const QModelIndexList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeData(this, handle__mimeData, sigval1); @@ -681,13 +681,13 @@ class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfSearchModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QModelIndexList callback_return_value_QModelIndexList; + callback_return_value_QModelIndexList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { - callback_return_value_QList.push_back(*(callback_return_value_arr[i])); + callback_return_value_QModelIndexList.push_back(*(callback_return_value_arr[i])); } - return callback_return_value_QList; + return callback_return_value_QModelIndexList; } friend struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags); @@ -920,12 +920,12 @@ struct miqt_string QPdfSearchModel_trUtf8(const char* s) { struct miqt_array /* of QPdfSearchResult* */ QPdfSearchModel_resultsOnPage(const QPdfSearchModel* self, int page) { QVector _ret = self->resultsOnPage(static_cast(page)); // Convert QList<> from C++ memory to manually-managed C memory - QPdfSearchResult** _arr = static_cast(malloc(sizeof(QPdfSearchResult*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPdfSearchResult** _arr = static_cast(malloc(sizeof(QPdfSearchResult*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPdfSearchResult(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1288,8 +1288,8 @@ bool QPdfSearchModel_override_virtual_mimeTypes(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self) { QStringList _ret = static_cast(self)->QPdfSearchModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1300,7 +1300,7 @@ struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1316,13 +1316,13 @@ bool QPdfSearchModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - return static_cast(self)->QPdfSearchModel::mimeData(indexes_QList); + return static_cast(self)->QPdfSearchModel::mimeData(indexes_QModelIndexList); } bool QPdfSearchModel_override_virtual_canDropMimeData(void* self, intptr_t slot) { @@ -1522,12 +1522,12 @@ bool QPdfSearchModel_override_virtual_match(void* self, intptr_t slot) { struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { QModelIndexList _ret = static_cast(self)->QPdfSearchModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1699,13 +1699,13 @@ void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; - indexes_QList.reserve(indexes.len); + QModelIndexList indexes_QModelIndexList; + indexes_QModelIndexList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { - indexes_QList.push_back(*(indexes_arr[i])); + indexes_QModelIndexList.push_back(*(indexes_arr[i])); } - self_cast->encodeData(indexes_QList, *stream); + self_cast->encodeData(indexes_QModelIndexList, *stream); } bool QPdfSearchModel_protectedbase_decodeData(bool* _dynamic_cast_ok, void* self, int row, int column, QModelIndex* parent, QDataStream* stream) { @@ -1892,19 +1892,19 @@ void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast } *_dynamic_cast_ok = true; - QModelIndexList from_QList; - from_QList.reserve(from.len); + QModelIndexList from_QModelIndexList; + from_QModelIndexList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { - from_QList.push_back(*(from_arr[i])); + from_QModelIndexList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; - to_QList.reserve(to.len); + QModelIndexList to_QModelIndexList; + to_QModelIndexList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { - to_QList.push_back(*(to_arr[i])); + to_QModelIndexList.push_back(*(to_arr[i])); } - self_cast->changePersistentIndexList(from_QList, to_QList); + self_cast->changePersistentIndexList(from_QModelIndexList, to_QModelIndexList); } struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persistentIndexList(bool* _dynamic_cast_ok, const void* self) { @@ -1917,12 +1917,12 @@ struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persisten *_dynamic_cast_ok = true; QModelIndexList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/pdf/gen_qpdfsearchresult.cpp b/qt/pdf/gen_qpdfsearchresult.cpp index 32b7ee40d1..ecf3e45ac3 100644 --- a/qt/pdf/gen_qpdfsearchresult.cpp +++ b/qt/pdf/gen_qpdfsearchresult.cpp @@ -53,12 +53,12 @@ struct miqt_string QPdfSearchResult_contextAfter(const QPdfSearchResult* self) { struct miqt_array /* of QRectF* */ QPdfSearchResult_rectangles(const QPdfSearchResult* self) { QVector _ret = self->rectangles(); // Convert QList<> from C++ memory to manually-managed C memory - QRectF** _arr = static_cast(malloc(sizeof(QRectF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QRectF** _arr = static_cast(malloc(sizeof(QRectF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QRectF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/printsupport/gen_qprinter.cpp b/qt/printsupport/gen_qprinter.cpp index 1f9d73f38a..0b2e94ac74 100644 --- a/qt/printsupport/gen_qprinter.cpp +++ b/qt/printsupport/gen_qprinter.cpp @@ -485,12 +485,12 @@ int QPrinter_duplex(const QPrinter* self) { struct miqt_array /* of int */ QPrinter_supportedResolutions(const QPrinter* self) { QList _ret = self->supportedResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/printsupport/gen_qprinterinfo.cpp b/qt/printsupport/gen_qprinterinfo.cpp index 8918f58608..4eaf9a1e45 100644 --- a/qt/printsupport/gen_qprinterinfo.cpp +++ b/qt/printsupport/gen_qprinterinfo.cpp @@ -98,12 +98,12 @@ int QPrinterInfo_state(const QPrinterInfo* self) { struct miqt_array /* of QPageSize* */ QPrinterInfo_supportedPageSizes(const QPrinterInfo* self) { QList _ret = self->supportedPageSizes(); // Convert QList<> from C++ memory to manually-managed C memory - QPageSize** _arr = static_cast(malloc(sizeof(QPageSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPageSize** _arr = static_cast(malloc(sizeof(QPageSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPageSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -127,13 +127,13 @@ QPageSize* QPrinterInfo_maximumPhysicalPageSize(const QPrinterInfo* self) { struct miqt_array /* of int */ QPrinterInfo_supportedPaperSizes(const QPrinterInfo* self) { QList _ret = self->supportedPaperSizes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPagedPaintDevice::PageSize _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -141,8 +141,8 @@ struct miqt_array /* of int */ QPrinterInfo_supportedPaperSizes(const QPrinterI struct miqt_array /* of struct miqt_map tuple of struct miqt_string and QSizeF* */ QPrinterInfo_supportedSizesWithNames(const QPrinterInfo* self) { QList> _ret = self->supportedSizesWithNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and QSizeF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and QSizeF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and QSizeF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and QSizeF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -163,7 +163,7 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and QSizeF* _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -171,12 +171,12 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and QSizeF* struct miqt_array /* of int */ QPrinterInfo_supportedResolutions(const QPrinterInfo* self) { QList _ret = self->supportedResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -189,13 +189,13 @@ int QPrinterInfo_defaultDuplexMode(const QPrinterInfo* self) { struct miqt_array /* of int */ QPrinterInfo_supportedDuplexModes(const QPrinterInfo* self) { QList _ret = self->supportedDuplexModes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPrinter::DuplexMode _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -208,13 +208,13 @@ int QPrinterInfo_defaultColorMode(const QPrinterInfo* self) { struct miqt_array /* of int */ QPrinterInfo_supportedColorModes(const QPrinterInfo* self) { QList _ret = self->supportedColorModes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPrinter::ColorMode _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -222,8 +222,8 @@ struct miqt_array /* of int */ QPrinterInfo_supportedColorModes(const QPrinterI struct miqt_array /* of struct miqt_string */ QPrinterInfo_availablePrinterNames() { QStringList _ret = QPrinterInfo::availablePrinterNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -234,7 +234,7 @@ struct miqt_array /* of struct miqt_string */ QPrinterInfo_availablePrinterName _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -242,12 +242,12 @@ struct miqt_array /* of struct miqt_string */ QPrinterInfo_availablePrinterName struct miqt_array /* of QPrinterInfo* */ QPrinterInfo_availablePrinters() { QList _ret = QPrinterInfo::availablePrinters(); // Convert QList<> from C++ memory to manually-managed C memory - QPrinterInfo** _arr = static_cast(malloc(sizeof(QPrinterInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPrinterInfo** _arr = static_cast(malloc(sizeof(QPrinterInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPrinterInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/script/gen_qscriptcontext.cpp b/qt/script/gen_qscriptcontext.cpp index cfacbcdf99..be81ea04cc 100644 --- a/qt/script/gen_qscriptcontext.cpp +++ b/qt/script/gen_qscriptcontext.cpp @@ -48,12 +48,12 @@ QScriptValue* QScriptContext_argumentsObject(const QScriptContext* self) { struct miqt_array /* of QScriptValue* */ QScriptContext_scopeChain(const QScriptContext* self) { QScriptValueList _ret = self->scopeChain(); // Convert QList<> from C++ memory to manually-managed C memory - QScriptValue** _arr = static_cast(malloc(sizeof(QScriptValue*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QScriptValue** _arr = static_cast(malloc(sizeof(QScriptValue*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QScriptValue(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -111,8 +111,8 @@ QScriptValue* QScriptContext_throwErrorWithText(QScriptContext* self, struct miq struct miqt_array /* of struct miqt_string */ QScriptContext_backtrace(const QScriptContext* self) { QStringList _ret = self->backtrace(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -123,7 +123,7 @@ struct miqt_array /* of struct miqt_string */ QScriptContext_backtrace(const QS _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/script/gen_qscriptcontextinfo.cpp b/qt/script/gen_qscriptcontextinfo.cpp index 30db2380d1..e7268e22e5 100644 --- a/qt/script/gen_qscriptcontextinfo.cpp +++ b/qt/script/gen_qscriptcontextinfo.cpp @@ -78,8 +78,8 @@ int QScriptContextInfo_functionType(const QScriptContextInfo* self) { struct miqt_array /* of struct miqt_string */ QScriptContextInfo_functionParameterNames(const QScriptContextInfo* self) { QStringList _ret = self->functionParameterNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -90,7 +90,7 @@ struct miqt_array /* of struct miqt_string */ QScriptContextInfo_functionParame _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/script/gen_qscriptengine.cpp b/qt/script/gen_qscriptengine.cpp index 3afcdc9621..f118398510 100644 --- a/qt/script/gen_qscriptengine.cpp +++ b/qt/script/gen_qscriptengine.cpp @@ -315,8 +315,8 @@ int QScriptEngine_uncaughtExceptionLineNumber(const QScriptEngine* self) { struct miqt_array /* of struct miqt_string */ QScriptEngine_uncaughtExceptionBacktrace(const QScriptEngine* self) { QStringList _ret = self->uncaughtExceptionBacktrace(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -327,7 +327,7 @@ struct miqt_array /* of struct miqt_string */ QScriptEngine_uncaughtExceptionBa _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -418,8 +418,8 @@ QScriptValue* QScriptEngine_importExtension(QScriptEngine* self, struct miqt_str struct miqt_array /* of struct miqt_string */ QScriptEngine_availableExtensions(const QScriptEngine* self) { QStringList _ret = self->availableExtensions(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -430,7 +430,7 @@ struct miqt_array /* of struct miqt_string */ QScriptEngine_availableExtensions _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -438,8 +438,8 @@ struct miqt_array /* of struct miqt_string */ QScriptEngine_availableExtensions struct miqt_array /* of struct miqt_string */ QScriptEngine_importedExtensions(const QScriptEngine* self) { QStringList _ret = self->importedExtensions(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -450,7 +450,7 @@ struct miqt_array /* of struct miqt_string */ QScriptEngine_importedExtensions( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/script/gen_qscriptextensioninterface.cpp b/qt/script/gen_qscriptextensioninterface.cpp index e65db153cd..a0efae8b85 100644 --- a/qt/script/gen_qscriptextensioninterface.cpp +++ b/qt/script/gen_qscriptextensioninterface.cpp @@ -57,14 +57,14 @@ class MiqtVirtualQScriptExtensionInterface final : public QScriptExtensionInterf } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QScriptExtensionInterface_keys(this, handle__keys); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } }; diff --git a/qt/script/gen_qscriptextensionplugin.cpp b/qt/script/gen_qscriptextensionplugin.cpp index d6d55745b2..eae186a809 100644 --- a/qt/script/gen_qscriptextensionplugin.cpp +++ b/qt/script/gen_qscriptextensionplugin.cpp @@ -51,14 +51,14 @@ class MiqtVirtualQScriptExtensionPlugin final : public QScriptExtensionPlugin { } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QScriptExtensionPlugin_keys(this, handle__keys); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } // cgo.Handle value for overwritten implementation @@ -258,8 +258,8 @@ struct miqt_string QScriptExtensionPlugin_trUtf8(const char* s) { struct miqt_array /* of struct miqt_string */ QScriptExtensionPlugin_keys(const QScriptExtensionPlugin* self) { QStringList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -270,7 +270,7 @@ struct miqt_array /* of struct miqt_string */ QScriptExtensionPlugin_keys(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/script/gen_qscriptvalue.cpp b/qt/script/gen_qscriptvalue.cpp index a6a67375e1..c1017111fb 100644 --- a/qt/script/gen_qscriptvalue.cpp +++ b/qt/script/gen_qscriptvalue.cpp @@ -376,23 +376,23 @@ QScriptValue* QScriptValue_callWithThisObject(QScriptValue* self, QScriptValue* } QScriptValue* QScriptValue_call3(QScriptValue* self, QScriptValue* thisObject, struct miqt_array /* of QScriptValue* */ args) { - QScriptValueList args_QList; - args_QList.reserve(args.len); + QScriptValueList args_QScriptValueList; + args_QScriptValueList.reserve(args.len); QScriptValue** args_arr = static_cast(args.data); for(size_t i = 0; i < args.len; ++i) { - args_QList.push_back(*(args_arr[i])); + args_QScriptValueList.push_back(*(args_arr[i])); } - return new QScriptValue(self->call(*thisObject, args_QList)); + return new QScriptValue(self->call(*thisObject, args_QScriptValueList)); } QScriptValue* QScriptValue_constructWithArgs(QScriptValue* self, struct miqt_array /* of QScriptValue* */ args) { - QScriptValueList args_QList; - args_QList.reserve(args.len); + QScriptValueList args_QScriptValueList; + args_QScriptValueList.reserve(args.len); QScriptValue** args_arr = static_cast(args.data); for(size_t i = 0; i < args.len; ++i) { - args_QList.push_back(*(args_arr[i])); + args_QScriptValueList.push_back(*(args_arr[i])); } - return new QScriptValue(self->construct(args_QList)); + return new QScriptValue(self->construct(args_QScriptValueList)); } void QScriptValue_delete(QScriptValue* self) { diff --git a/qt/webengine/gen_qwebenginecertificateerror.cpp b/qt/webengine/gen_qwebenginecertificateerror.cpp index f5de1c26e6..b07447a045 100644 --- a/qt/webengine/gen_qwebenginecertificateerror.cpp +++ b/qt/webengine/gen_qwebenginecertificateerror.cpp @@ -76,12 +76,12 @@ bool QWebEngineCertificateError_answered(const QWebEngineCertificateError* self) struct miqt_array /* of QSslCertificate* */ QWebEngineCertificateError_certificateChain(const QWebEngineCertificateError* self) { QList _ret = self->certificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebengineclientcertificateselection.cpp b/qt/webengine/gen_qwebengineclientcertificateselection.cpp index bd96ed2009..3ec0b29622 100644 --- a/qt/webengine/gen_qwebengineclientcertificateselection.cpp +++ b/qt/webengine/gen_qwebengineclientcertificateselection.cpp @@ -36,12 +36,12 @@ void QWebEngineClientCertificateSelection_selectNone(QWebEngineClientCertificate struct miqt_array /* of QSslCertificate* */ QWebEngineClientCertificateSelection_certificates(const QWebEngineClientCertificateSelection* self) { QVector _ret = self->certificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebengineclientcertificatestore.cpp b/qt/webengine/gen_qwebengineclientcertificatestore.cpp index 8f398b315d..2f51b6f77d 100644 --- a/qt/webengine/gen_qwebengineclientcertificatestore.cpp +++ b/qt/webengine/gen_qwebengineclientcertificatestore.cpp @@ -20,12 +20,12 @@ void QWebEngineClientCertificateStore_add(QWebEngineClientCertificateStore* self struct miqt_array /* of QSslCertificate* */ QWebEngineClientCertificateStore_certificates(const QWebEngineClientCertificateStore* self) { QVector _ret = self->certificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebenginecontextmenudata.cpp b/qt/webengine/gen_qwebenginecontextmenudata.cpp index 9400b10f04..3b69158941 100644 --- a/qt/webengine/gen_qwebenginecontextmenudata.cpp +++ b/qt/webengine/gen_qwebenginecontextmenudata.cpp @@ -89,8 +89,8 @@ struct miqt_string QWebEngineContextMenuData_misspelledWord(const QWebEngineCont struct miqt_array /* of struct miqt_string */ QWebEngineContextMenuData_spellCheckerSuggestions(const QWebEngineContextMenuData* self) { QStringList _ret = self->spellCheckerSuggestions(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -101,7 +101,7 @@ struct miqt_array /* of struct miqt_string */ QWebEngineContextMenuData_spellCh _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebenginehistory.cpp b/qt/webengine/gen_qwebenginehistory.cpp index cce2e197c9..d172237eb0 100644 --- a/qt/webengine/gen_qwebenginehistory.cpp +++ b/qt/webengine/gen_qwebenginehistory.cpp @@ -71,12 +71,12 @@ void QWebEngineHistory_clear(QWebEngineHistory* self) { struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_items(const QWebEngineHistory* self) { QList _ret = self->items(); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -84,12 +84,12 @@ struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_items(const struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_backItems(const QWebEngineHistory* self, int maxItems) { QList _ret = self->backItems(static_cast(maxItems)); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -97,12 +97,12 @@ struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_backItems(c struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_forwardItems(const QWebEngineHistory* self, int maxItems) { QList _ret = self->forwardItems(static_cast(maxItems)); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebenginehttprequest.cpp b/qt/webengine/gen_qwebenginehttprequest.cpp index 8822e811f4..75dae844de 100644 --- a/qt/webengine/gen_qwebenginehttprequest.cpp +++ b/qt/webengine/gen_qwebenginehttprequest.cpp @@ -100,8 +100,8 @@ bool QWebEngineHttpRequest_hasHeader(const QWebEngineHttpRequest* self, struct m struct miqt_array /* of struct miqt_string */ QWebEngineHttpRequest_headers(const QWebEngineHttpRequest* self) { QVector _ret = self->headers(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _vv_qb = _ret[i]; struct miqt_string _vv_ms; _vv_ms.len = _vv_qb.length(); @@ -110,7 +110,7 @@ struct miqt_array /* of struct miqt_string */ QWebEngineHttpRequest_headers(con _arr[i] = _vv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebenginepage.cpp b/qt/webengine/gen_qwebenginepage.cpp index 46b1b15bdd..0eed451597 100644 --- a/qt/webengine/gen_qwebenginepage.cpp +++ b/qt/webengine/gen_qwebenginepage.cpp @@ -165,8 +165,8 @@ class MiqtVirtualQWebEnginePage final : public QWebEnginePage { int sigval1 = static_cast(mode_ret); const QStringList& oldFiles_ret = oldFiles; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* oldFiles_arr = static_cast(malloc(sizeof(struct miqt_string) * oldFiles_ret.length())); - for (size_t i = 0, e = oldFiles_ret.length(); i < e; ++i) { + struct miqt_string* oldFiles_arr = static_cast(malloc(sizeof(struct miqt_string) * oldFiles_ret.size())); + for (size_t i = 0, e = oldFiles_ret.size(); i < e; ++i) { QString oldFiles_lv_ret = oldFiles_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray oldFiles_lv_b = oldFiles_lv_ret.toUtf8(); @@ -177,13 +177,13 @@ class MiqtVirtualQWebEnginePage final : public QWebEnginePage { oldFiles_arr[i] = oldFiles_lv_ms; } struct miqt_array oldFiles_out; - oldFiles_out.len = oldFiles_ret.length(); + oldFiles_out.len = oldFiles_ret.size(); oldFiles_out.data = static_cast(oldFiles_arr); struct miqt_array /* of struct miqt_string */ sigval2 = oldFiles_out; const QStringList& acceptedMimeTypes_ret = acceptedMimeTypes; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* acceptedMimeTypes_arr = static_cast(malloc(sizeof(struct miqt_string) * acceptedMimeTypes_ret.length())); - for (size_t i = 0, e = acceptedMimeTypes_ret.length(); i < e; ++i) { + struct miqt_string* acceptedMimeTypes_arr = static_cast(malloc(sizeof(struct miqt_string) * acceptedMimeTypes_ret.size())); + for (size_t i = 0, e = acceptedMimeTypes_ret.size(); i < e; ++i) { QString acceptedMimeTypes_lv_ret = acceptedMimeTypes_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray acceptedMimeTypes_lv_b = acceptedMimeTypes_lv_ret.toUtf8(); @@ -194,18 +194,18 @@ class MiqtVirtualQWebEnginePage final : public QWebEnginePage { acceptedMimeTypes_arr[i] = acceptedMimeTypes_lv_ms; } struct miqt_array acceptedMimeTypes_out; - acceptedMimeTypes_out.len = acceptedMimeTypes_ret.length(); + acceptedMimeTypes_out.len = acceptedMimeTypes_ret.size(); acceptedMimeTypes_out.data = static_cast(acceptedMimeTypes_arr); struct miqt_array /* of struct miqt_string */ sigval3 = acceptedMimeTypes_out; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QWebEnginePage_chooseFiles(this, handle__chooseFiles, sigval1, sigval2, sigval3); - QStringList callback_return_value_QList; - callback_return_value_QList.reserve(callback_return_value.len); + QStringList callback_return_value_QStringList; + callback_return_value_QStringList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { QString callback_return_value_arr_i_QString = QString::fromUtf8(callback_return_value_arr[i].data, callback_return_value_arr[i].len); - callback_return_value_QList.push_back(callback_return_value_arr_i_QString); + callback_return_value_QStringList.push_back(callback_return_value_arr_i_QString); } - return callback_return_value_QList; + return callback_return_value_QStringList; } friend struct miqt_array /* of struct miqt_string */ QWebEnginePage_virtualbase_chooseFiles(void* self, int mode, struct miqt_array /* of struct miqt_string */ oldFiles, struct miqt_array /* of struct miqt_string */ acceptedMimeTypes); @@ -557,10 +557,6 @@ QMenu* QWebEnginePage_createStandardContextMenu(QWebEnginePage* self) { return self->createStandardContextMenu(); } -void QWebEnginePage_setFeaturePermission(QWebEnginePage* self, QUrl* securityOrigin, int feature, int policy) { - self->setFeaturePermission(*securityOrigin, static_cast(feature), static_cast(policy)); -} - void QWebEnginePage_load(QWebEnginePage* self, QUrl* url) { self->load(*url); } @@ -1273,24 +1269,24 @@ bool QWebEnginePage_override_virtual_chooseFiles(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QWebEnginePage_virtualbase_chooseFiles(void* self, int mode, struct miqt_array /* of struct miqt_string */ oldFiles, struct miqt_array /* of struct miqt_string */ acceptedMimeTypes) { - QStringList oldFiles_QList; - oldFiles_QList.reserve(oldFiles.len); + QStringList oldFiles_QStringList; + oldFiles_QStringList.reserve(oldFiles.len); struct miqt_string* oldFiles_arr = static_cast(oldFiles.data); for(size_t i = 0; i < oldFiles.len; ++i) { QString oldFiles_arr_i_QString = QString::fromUtf8(oldFiles_arr[i].data, oldFiles_arr[i].len); - oldFiles_QList.push_back(oldFiles_arr_i_QString); + oldFiles_QStringList.push_back(oldFiles_arr_i_QString); } - QStringList acceptedMimeTypes_QList; - acceptedMimeTypes_QList.reserve(acceptedMimeTypes.len); + QStringList acceptedMimeTypes_QStringList; + acceptedMimeTypes_QStringList.reserve(acceptedMimeTypes.len); struct miqt_string* acceptedMimeTypes_arr = static_cast(acceptedMimeTypes.data); for(size_t i = 0; i < acceptedMimeTypes.len; ++i) { QString acceptedMimeTypes_arr_i_QString = QString::fromUtf8(acceptedMimeTypes_arr[i].data, acceptedMimeTypes_arr[i].len); - acceptedMimeTypes_QList.push_back(acceptedMimeTypes_arr_i_QString); + acceptedMimeTypes_QStringList.push_back(acceptedMimeTypes_arr_i_QString); } - QStringList _ret = static_cast(self)->QWebEnginePage::chooseFiles(static_cast(mode), oldFiles_QList, acceptedMimeTypes_QList); + QStringList _ret = static_cast(self)->QWebEnginePage::chooseFiles(static_cast(mode), oldFiles_QStringList, acceptedMimeTypes_QStringList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1301,7 +1297,7 @@ struct miqt_array /* of struct miqt_string */ QWebEnginePage_virtualbase_choose _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebenginepage.go b/qt/webengine/gen_qwebenginepage.go index f1cddfd5ac..606d8ed67b 100644 --- a/qt/webengine/gen_qwebenginepage.go +++ b/qt/webengine/gen_qwebenginepage.go @@ -297,10 +297,6 @@ func (this *QWebEnginePage) CreateStandardContextMenu() *qt.QMenu { return qt.UnsafeNewQMenu(unsafe.Pointer(C.QWebEnginePage_createStandardContextMenu(this.h))) } -func (this *QWebEnginePage) SetFeaturePermission(securityOrigin *qt.QUrl, feature QWebEnginePage__Feature, policy QWebEnginePage__PermissionPolicy) { - C.QWebEnginePage_setFeaturePermission(this.h, (*C.QUrl)(securityOrigin.UnsafePointer()), (C.int)(feature), (C.int)(policy)) -} - func (this *QWebEnginePage) Load(url *qt.QUrl) { C.QWebEnginePage_load(this.h, (*C.QUrl)(url.UnsafePointer())) } diff --git a/qt/webengine/gen_qwebenginepage.h b/qt/webengine/gen_qwebenginepage.h index 1b24669583..b8f11eb19a 100644 --- a/qt/webengine/gen_qwebenginepage.h +++ b/qt/webengine/gen_qwebenginepage.h @@ -101,7 +101,6 @@ void QWebEnginePage_replaceMisspelledWord(QWebEnginePage* self, struct miqt_stri bool QWebEnginePage_event(QWebEnginePage* self, QEvent* param1); void QWebEnginePage_findText(QWebEnginePage* self, struct miqt_string subString); QMenu* QWebEnginePage_createStandardContextMenu(QWebEnginePage* self); -void QWebEnginePage_setFeaturePermission(QWebEnginePage* self, QUrl* securityOrigin, int feature, int policy); void QWebEnginePage_load(QWebEnginePage* self, QUrl* url); void QWebEnginePage_loadWithRequest(QWebEnginePage* self, QWebEngineHttpRequest* request); void QWebEnginePage_download(QWebEnginePage* self, QUrl* url); diff --git a/qt/webengine/gen_qwebengineprofile.cpp b/qt/webengine/gen_qwebengineprofile.cpp index 494781f221..a7d89e8637 100644 --- a/qt/webengine/gen_qwebengineprofile.cpp +++ b/qt/webengine/gen_qwebengineprofile.cpp @@ -399,21 +399,21 @@ void QWebEngineProfile_clearHttpCache(QWebEngineProfile* self) { } void QWebEngineProfile_setSpellCheckLanguages(QWebEngineProfile* self, struct miqt_array /* of struct miqt_string */ languages) { - QStringList languages_QList; - languages_QList.reserve(languages.len); + QStringList languages_QStringList; + languages_QStringList.reserve(languages.len); struct miqt_string* languages_arr = static_cast(languages.data); for(size_t i = 0; i < languages.len; ++i) { QString languages_arr_i_QString = QString::fromUtf8(languages_arr[i].data, languages_arr[i].len); - languages_QList.push_back(languages_arr_i_QString); + languages_QStringList.push_back(languages_arr_i_QString); } - self->setSpellCheckLanguages(languages_QList); + self->setSpellCheckLanguages(languages_QStringList); } struct miqt_array /* of struct miqt_string */ QWebEngineProfile_spellCheckLanguages(const QWebEngineProfile* self) { QStringList _ret = self->spellCheckLanguages(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -424,7 +424,7 @@ struct miqt_array /* of struct miqt_string */ QWebEngineProfile_spellCheckLangu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webengine/gen_qwebenginescriptcollection.cpp b/qt/webengine/gen_qwebenginescriptcollection.cpp index beb3b485b5..40225524a5 100644 --- a/qt/webengine/gen_qwebenginescriptcollection.cpp +++ b/qt/webengine/gen_qwebenginescriptcollection.cpp @@ -40,12 +40,12 @@ struct miqt_array /* of QWebEngineScript* */ QWebEngineScriptCollection_findScr QString name_QString = QString::fromUtf8(name.data, name.len); QList _ret = self->findScripts(name_QString); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineScript(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -75,12 +75,12 @@ void QWebEngineScriptCollection_clear(QWebEngineScriptCollection* self) { struct miqt_array /* of QWebEngineScript* */ QWebEngineScriptCollection_toList(const QWebEngineScriptCollection* self) { QList _ret = self->toList(); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineScript(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webkit/gen_qwebelement.cpp b/qt/webkit/gen_qwebelement.cpp index 6a17c7575c..dae6f679bb 100644 --- a/qt/webkit/gen_qwebelement.cpp +++ b/qt/webkit/gen_qwebelement.cpp @@ -170,8 +170,8 @@ bool QWebElement_hasAttributes(const QWebElement* self) { struct miqt_array /* of struct miqt_string */ QWebElement_attributeNames(const QWebElement* self) { QStringList _ret = self->attributeNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -182,7 +182,7 @@ struct miqt_array /* of struct miqt_string */ QWebElement_attributeNames(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -190,8 +190,8 @@ struct miqt_array /* of struct miqt_string */ QWebElement_attributeNames(const struct miqt_array /* of struct miqt_string */ QWebElement_classes(const QWebElement* self) { QStringList _ret = self->classes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -202,7 +202,7 @@ struct miqt_array /* of struct miqt_string */ QWebElement_classes(const QWebEle _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -454,8 +454,8 @@ struct miqt_array /* of struct miqt_string */ QWebElement_attributeNamesWithNam QString namespaceUri_QString = QString::fromUtf8(namespaceUri.data, namespaceUri.len); QStringList _ret = self->attributeNames(namespaceUri_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -466,7 +466,7 @@ struct miqt_array /* of struct miqt_string */ QWebElement_attributeNamesWithNam _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -529,12 +529,12 @@ QWebElement* QWebElementCollection_last(const QWebElementCollection* self) { struct miqt_array /* of QWebElement* */ QWebElementCollection_toList(const QWebElementCollection* self) { QList _ret = self->toList(); // Convert QList<> from C++ memory to manually-managed C memory - QWebElement** _arr = static_cast(malloc(sizeof(QWebElement*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebElement** _arr = static_cast(malloc(sizeof(QWebElement*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebElement(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webkit/gen_qwebframe.cpp b/qt/webkit/gen_qwebframe.cpp index 56c5df6bb1..1bc84c4277 100644 --- a/qt/webkit/gen_qwebframe.cpp +++ b/qt/webkit/gen_qwebframe.cpp @@ -297,12 +297,12 @@ QWebFrame* QWebFrame_parentFrame(const QWebFrame* self) { struct miqt_array /* of QWebFrame* */ QWebFrame_childFrames(const QWebFrame* self) { QList _ret = self->childFrames(); // Convert QList<> from C++ memory to manually-managed C memory - QWebFrame** _arr = static_cast(malloc(sizeof(QWebFrame*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebFrame** _arr = static_cast(malloc(sizeof(QWebFrame*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webkit/gen_qwebhistory.cpp b/qt/webkit/gen_qwebhistory.cpp index 5cc52ec39b..79b6dfd379 100644 --- a/qt/webkit/gen_qwebhistory.cpp +++ b/qt/webkit/gen_qwebhistory.cpp @@ -114,12 +114,12 @@ void QWebHistory_clear(QWebHistory* self) { struct miqt_array /* of QWebHistoryItem* */ QWebHistory_items(const QWebHistory* self) { QList _ret = self->items(); // Convert QList<> from C++ memory to manually-managed C memory - QWebHistoryItem** _arr = static_cast(malloc(sizeof(QWebHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebHistoryItem** _arr = static_cast(malloc(sizeof(QWebHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -127,12 +127,12 @@ struct miqt_array /* of QWebHistoryItem* */ QWebHistory_items(const QWebHistory struct miqt_array /* of QWebHistoryItem* */ QWebHistory_backItems(const QWebHistory* self, int maxItems) { QList _ret = self->backItems(static_cast(maxItems)); // Convert QList<> from C++ memory to manually-managed C memory - QWebHistoryItem** _arr = static_cast(malloc(sizeof(QWebHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebHistoryItem** _arr = static_cast(malloc(sizeof(QWebHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -140,12 +140,12 @@ struct miqt_array /* of QWebHistoryItem* */ QWebHistory_backItems(const QWebHis struct miqt_array /* of QWebHistoryItem* */ QWebHistory_forwardItems(const QWebHistory* self, int maxItems) { QList _ret = self->forwardItems(static_cast(maxItems)); // Convert QList<> from C++ memory to manually-managed C memory - QWebHistoryItem** _arr = static_cast(malloc(sizeof(QWebHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebHistoryItem** _arr = static_cast(malloc(sizeof(QWebHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webkit/gen_qwebkitplatformplugin.cpp b/qt/webkit/gen_qwebkitplatformplugin.cpp index 5f3c536f7e..cac454ee32 100644 --- a/qt/webkit/gen_qwebkitplatformplugin.cpp +++ b/qt/webkit/gen_qwebkitplatformplugin.cpp @@ -610,14 +610,14 @@ struct miqt_string QWebSpellChecker_autoCorrectSuggestionForMisspelledWord(QWebS void QWebSpellChecker_guessesForWord(QWebSpellChecker* self, struct miqt_string word, struct miqt_string context, struct miqt_array /* of struct miqt_string */ guesses) { QString word_QString = QString::fromUtf8(word.data, word.len); QString context_QString = QString::fromUtf8(context.data, context.len); - QStringList guesses_QList; - guesses_QList.reserve(guesses.len); + QStringList guesses_QStringList; + guesses_QStringList.reserve(guesses.len); struct miqt_string* guesses_arr = static_cast(guesses.data); for(size_t i = 0; i < guesses.len; ++i) { QString guesses_arr_i_QString = QString::fromUtf8(guesses_arr[i].data, guesses_arr[i].len); - guesses_QList.push_back(guesses_arr_i_QString); + guesses_QStringList.push_back(guesses_arr_i_QString); } - self->guessesForWord(word_QString, context_QString, guesses_QList); + self->guessesForWord(word_QString, context_QString, guesses_QStringList); } bool QWebSpellChecker_isGrammarCheckingEnabled(QWebSpellChecker* self) { diff --git a/qt/webkit/gen_qwebpage.cpp b/qt/webkit/gen_qwebpage.cpp index 20bb12c5a8..8304404440 100644 --- a/qt/webkit/gen_qwebpage.cpp +++ b/qt/webkit/gen_qwebpage.cpp @@ -233,8 +233,8 @@ class MiqtVirtualQWebPage final : public QWebPage { QUrl* sigval2 = const_cast(&url_ret); const QStringList& paramNames_ret = paramNames; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* paramNames_arr = static_cast(malloc(sizeof(struct miqt_string) * paramNames_ret.length())); - for (size_t i = 0, e = paramNames_ret.length(); i < e; ++i) { + struct miqt_string* paramNames_arr = static_cast(malloc(sizeof(struct miqt_string) * paramNames_ret.size())); + for (size_t i = 0, e = paramNames_ret.size(); i < e; ++i) { QString paramNames_lv_ret = paramNames_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray paramNames_lv_b = paramNames_lv_ret.toUtf8(); @@ -245,13 +245,13 @@ class MiqtVirtualQWebPage final : public QWebPage { paramNames_arr[i] = paramNames_lv_ms; } struct miqt_array paramNames_out; - paramNames_out.len = paramNames_ret.length(); + paramNames_out.len = paramNames_ret.size(); paramNames_out.data = static_cast(paramNames_arr); struct miqt_array /* of struct miqt_string */ sigval3 = paramNames_out; const QStringList& paramValues_ret = paramValues; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* paramValues_arr = static_cast(malloc(sizeof(struct miqt_string) * paramValues_ret.length())); - for (size_t i = 0, e = paramValues_ret.length(); i < e; ++i) { + struct miqt_string* paramValues_arr = static_cast(malloc(sizeof(struct miqt_string) * paramValues_ret.size())); + for (size_t i = 0, e = paramValues_ret.size(); i < e; ++i) { QString paramValues_lv_ret = paramValues_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray paramValues_lv_b = paramValues_lv_ret.toUtf8(); @@ -262,7 +262,7 @@ class MiqtVirtualQWebPage final : public QWebPage { paramValues_arr[i] = paramValues_lv_ms; } struct miqt_array paramValues_out; - paramValues_out.len = paramValues_ret.length(); + paramValues_out.len = paramValues_ret.size(); paramValues_out.data = static_cast(paramValues_arr); struct miqt_array /* of struct miqt_string */ sigval4 = paramValues_out; QObject* callback_return_value = miqt_exec_callback_QWebPage_createPlugin(this, handle__createPlugin, sigval1, sigval2, sigval3, sigval4); @@ -792,8 +792,8 @@ void QWebPage_setFeaturePermission(QWebPage* self, QWebFrame* frame, int feature struct miqt_array /* of struct miqt_string */ QWebPage_supportedContentTypes(const QWebPage* self) { QStringList _ret = self->supportedContentTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -804,7 +804,7 @@ struct miqt_array /* of struct miqt_string */ QWebPage_supportedContentTypes(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1394,21 +1394,21 @@ bool QWebPage_override_virtual_createPlugin(void* self, intptr_t slot) { QObject* QWebPage_virtualbase_createPlugin(void* self, struct miqt_string classid, QUrl* url, struct miqt_array /* of struct miqt_string */ paramNames, struct miqt_array /* of struct miqt_string */ paramValues) { QString classid_QString = QString::fromUtf8(classid.data, classid.len); - QStringList paramNames_QList; - paramNames_QList.reserve(paramNames.len); + QStringList paramNames_QStringList; + paramNames_QStringList.reserve(paramNames.len); struct miqt_string* paramNames_arr = static_cast(paramNames.data); for(size_t i = 0; i < paramNames.len; ++i) { QString paramNames_arr_i_QString = QString::fromUtf8(paramNames_arr[i].data, paramNames_arr[i].len); - paramNames_QList.push_back(paramNames_arr_i_QString); + paramNames_QStringList.push_back(paramNames_arr_i_QString); } - QStringList paramValues_QList; - paramValues_QList.reserve(paramValues.len); + QStringList paramValues_QStringList; + paramValues_QStringList.reserve(paramValues.len); struct miqt_string* paramValues_arr = static_cast(paramValues.data); for(size_t i = 0; i < paramValues.len; ++i) { QString paramValues_arr_i_QString = QString::fromUtf8(paramValues_arr[i].data, paramValues_arr[i].len); - paramValues_QList.push_back(paramValues_arr_i_QString); + paramValues_QStringList.push_back(paramValues_arr_i_QString); } - return static_cast(self)->QWebPage::createPlugin(classid_QString, *url, paramNames_QList, paramValues_QList); + return static_cast(self)->QWebPage::createPlugin(classid_QString, *url, paramNames_QStringList, paramValues_QStringList); } bool QWebPage_override_virtual_acceptNavigationRequest(void* self, intptr_t slot) { diff --git a/qt/webkit/gen_qwebpluginfactory.cpp b/qt/webkit/gen_qwebpluginfactory.cpp index 34531df8a2..9600a3dd81 100644 --- a/qt/webkit/gen_qwebpluginfactory.cpp +++ b/qt/webkit/gen_qwebpluginfactory.cpp @@ -102,8 +102,8 @@ class MiqtVirtualQWebPluginFactory final : public QWebPluginFactory { QUrl* sigval2 = const_cast(¶m2_ret); const QStringList& argumentNames_ret = argumentNames; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* argumentNames_arr = static_cast(malloc(sizeof(struct miqt_string) * argumentNames_ret.length())); - for (size_t i = 0, e = argumentNames_ret.length(); i < e; ++i) { + struct miqt_string* argumentNames_arr = static_cast(malloc(sizeof(struct miqt_string) * argumentNames_ret.size())); + for (size_t i = 0, e = argumentNames_ret.size(); i < e; ++i) { QString argumentNames_lv_ret = argumentNames_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray argumentNames_lv_b = argumentNames_lv_ret.toUtf8(); @@ -114,13 +114,13 @@ class MiqtVirtualQWebPluginFactory final : public QWebPluginFactory { argumentNames_arr[i] = argumentNames_lv_ms; } struct miqt_array argumentNames_out; - argumentNames_out.len = argumentNames_ret.length(); + argumentNames_out.len = argumentNames_ret.size(); argumentNames_out.data = static_cast(argumentNames_arr); struct miqt_array /* of struct miqt_string */ sigval3 = argumentNames_out; const QStringList& argumentValues_ret = argumentValues; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* argumentValues_arr = static_cast(malloc(sizeof(struct miqt_string) * argumentValues_ret.length())); - for (size_t i = 0, e = argumentValues_ret.length(); i < e; ++i) { + struct miqt_string* argumentValues_arr = static_cast(malloc(sizeof(struct miqt_string) * argumentValues_ret.size())); + for (size_t i = 0, e = argumentValues_ret.size(); i < e; ++i) { QString argumentValues_lv_ret = argumentValues_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray argumentValues_lv_b = argumentValues_lv_ret.toUtf8(); @@ -131,7 +131,7 @@ class MiqtVirtualQWebPluginFactory final : public QWebPluginFactory { argumentValues_arr[i] = argumentValues_lv_ms; } struct miqt_array argumentValues_out; - argumentValues_out.len = argumentValues_ret.length(); + argumentValues_out.len = argumentValues_ret.size(); argumentValues_out.data = static_cast(argumentValues_arr); struct miqt_array /* of struct miqt_string */ sigval4 = argumentValues_out; QObject* callback_return_value = miqt_exec_callback_QWebPluginFactory_create(this, handle__create, sigval1, sigval2, sigval3, sigval4); @@ -348,12 +348,12 @@ struct miqt_string QWebPluginFactory_trUtf8(const char* s) { struct miqt_array /* of QWebPluginFactory__Plugin* */ QWebPluginFactory_plugins(const QWebPluginFactory* self) { QList _ret = self->plugins(); // Convert QList<> from C++ memory to manually-managed C memory - QWebPluginFactory__Plugin** _arr = static_cast(malloc(sizeof(QWebPluginFactory__Plugin*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebPluginFactory__Plugin** _arr = static_cast(malloc(sizeof(QWebPluginFactory__Plugin*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebPluginFactory::Plugin(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -364,21 +364,21 @@ void QWebPluginFactory_refreshPlugins(QWebPluginFactory* self) { QObject* QWebPluginFactory_create(const QWebPluginFactory* self, struct miqt_string mimeType, QUrl* param2, struct miqt_array /* of struct miqt_string */ argumentNames, struct miqt_array /* of struct miqt_string */ argumentValues) { QString mimeType_QString = QString::fromUtf8(mimeType.data, mimeType.len); - QStringList argumentNames_QList; - argumentNames_QList.reserve(argumentNames.len); + QStringList argumentNames_QStringList; + argumentNames_QStringList.reserve(argumentNames.len); struct miqt_string* argumentNames_arr = static_cast(argumentNames.data); for(size_t i = 0; i < argumentNames.len; ++i) { QString argumentNames_arr_i_QString = QString::fromUtf8(argumentNames_arr[i].data, argumentNames_arr[i].len); - argumentNames_QList.push_back(argumentNames_arr_i_QString); + argumentNames_QStringList.push_back(argumentNames_arr_i_QString); } - QStringList argumentValues_QList; - argumentValues_QList.reserve(argumentValues.len); + QStringList argumentValues_QStringList; + argumentValues_QStringList.reserve(argumentValues.len); struct miqt_string* argumentValues_arr = static_cast(argumentValues.data); for(size_t i = 0; i < argumentValues.len; ++i) { QString argumentValues_arr_i_QString = QString::fromUtf8(argumentValues_arr[i].data, argumentValues_arr[i].len); - argumentValues_QList.push_back(argumentValues_arr_i_QString); + argumentValues_QStringList.push_back(argumentValues_arr_i_QString); } - return self->create(mimeType_QString, *param2, argumentNames_QList, argumentValues_QList); + return self->create(mimeType_QString, *param2, argumentNames_QStringList, argumentValues_QStringList); } bool QWebPluginFactory_extension(QWebPluginFactory* self, int extension, QWebPluginFactory__ExtensionOption* option, QWebPluginFactory__ExtensionReturn* output) { diff --git a/qt/webkit/gen_qwebsecurityorigin.cpp b/qt/webkit/gen_qwebsecurityorigin.cpp index cbab769d0c..d69aabfc5a 100644 --- a/qt/webkit/gen_qwebsecurityorigin.cpp +++ b/qt/webkit/gen_qwebsecurityorigin.cpp @@ -27,12 +27,12 @@ QWebSecurityOrigin* QWebSecurityOrigin_new2(QWebSecurityOrigin* other) { struct miqt_array /* of QWebSecurityOrigin* */ QWebSecurityOrigin_allOrigins() { QList _ret = QWebSecurityOrigin::allOrigins(); // Convert QList<> from C++ memory to manually-managed C memory - QWebSecurityOrigin** _arr = static_cast(malloc(sizeof(QWebSecurityOrigin*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebSecurityOrigin** _arr = static_cast(malloc(sizeof(QWebSecurityOrigin*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebSecurityOrigin(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -50,8 +50,8 @@ void QWebSecurityOrigin_removeLocalScheme(struct miqt_string scheme) { struct miqt_array /* of struct miqt_string */ QWebSecurityOrigin_localSchemes() { QStringList _ret = QWebSecurityOrigin::localSchemes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -62,7 +62,7 @@ struct miqt_array /* of struct miqt_string */ QWebSecurityOrigin_localSchemes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -126,12 +126,12 @@ void QWebSecurityOrigin_setApplicationCacheQuota(QWebSecurityOrigin* self, long struct miqt_array /* of QWebDatabase* */ QWebSecurityOrigin_databases(const QWebSecurityOrigin* self) { QList _ret = self->databases(); // Convert QList<> from C++ memory to manually-managed C memory - QWebDatabase** _arr = static_cast(malloc(sizeof(QWebDatabase*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebDatabase** _arr = static_cast(malloc(sizeof(QWebDatabase*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebDatabase(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt/webkit/gen_qwebsettings.cpp b/qt/webkit/gen_qwebsettings.cpp index 4118fb1cbd..f04b1ebf90 100644 --- a/qt/webkit/gen_qwebsettings.cpp +++ b/qt/webkit/gen_qwebsettings.cpp @@ -114,21 +114,21 @@ QIcon* QWebSettings_iconForUrl(QUrl* url) { } void QWebSettings_setPluginSearchPaths(struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; - paths_QList.reserve(paths.len); + QStringList paths_QStringList; + paths_QStringList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { QString paths_arr_i_QString = QString::fromUtf8(paths_arr[i].data, paths_arr[i].len); - paths_QList.push_back(paths_arr_i_QString); + paths_QStringList.push_back(paths_arr_i_QString); } - QWebSettings::setPluginSearchPaths(paths_QList); + QWebSettings::setPluginSearchPaths(paths_QStringList); } struct miqt_array /* of struct miqt_string */ QWebSettings_pluginSearchPaths() { QStringList _ret = QWebSettings::pluginSearchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -139,7 +139,7 @@ struct miqt_array /* of struct miqt_string */ QWebSettings_pluginSearchPaths() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/cbor/gen_qcborarray.cpp b/qt6/cbor/gen_qcborarray.cpp index 2b4f98a262..0e8d2fa0cc 100644 --- a/qt6/cbor/gen_qcborarray.cpp +++ b/qt6/cbor/gen_qcborarray.cpp @@ -231,7 +231,7 @@ QCborArray* QCborArray_operatorShiftLeft(QCborArray* self, QCborValue* v) { } QCborArray* QCborArray_fromStringList(struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; + QList list_QList; list_QList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -242,7 +242,7 @@ QCborArray* QCborArray_fromStringList(struct miqt_array /* of struct miqt_string } QCborArray* QCborArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { - QVariantList list_QList; + QList list_QList; list_QList.reserve(list.len); QVariant** list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -256,14 +256,14 @@ QCborArray* QCborArray_fromJsonArray(QJsonArray* array) { } struct miqt_array /* of QVariant* */ QCborArray_toVariantList(const QCborArray* self) { - QVariantList _ret = self->toVariantList(); + QList _ret = self->toVariantList(); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/cbor/gen_qcbormap.cpp b/qt6/cbor/gen_qcbormap.cpp index 795587a31f..c755ea8c06 100644 --- a/qt6/cbor/gen_qcbormap.cpp +++ b/qt6/cbor/gen_qcbormap.cpp @@ -60,12 +60,12 @@ void QCborMap_clear(QCborMap* self) { struct miqt_array /* of QCborValue* */ QCborMap_keys(const QCborMap* self) { QList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - QCborValue** _arr = static_cast(malloc(sizeof(QCborValue*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCborValue** _arr = static_cast(malloc(sizeof(QCborValue*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCborValue(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -269,7 +269,7 @@ QCborMap__Iterator* QCborMap_insert4(QCborMap* self, QCborValue* key, QCborValue } QCborMap__Iterator* QCborMap_insertWithQCborMapvalueType(QCborMap* self, struct miqt_map /* tuple of QCborValue* and QCborValue* */ v) { - QCborMap::value_type v_QPair; + QPair v_QPair; QCborValue** v_first_arr = static_cast(v.keys); QCborValue** v_second_arr = static_cast(v.values); v_QPair.first = *(v_first_arr[0]); @@ -278,7 +278,7 @@ QCborMap__Iterator* QCborMap_insertWithQCborMapvalueType(QCborMap* self, struct } QCborMap* QCborMap_fromVariantMap(struct miqt_map /* of struct miqt_string to QVariant* */ map) { - QVariantMap map_QMap; + QMap map_QMap; struct miqt_string* map_karr = static_cast(map.keys); QVariant** map_varr = static_cast(map.values); for(size_t i = 0; i < map.len; ++i) { @@ -289,7 +289,7 @@ QCborMap* QCborMap_fromVariantMap(struct miqt_map /* of struct miqt_string to QV } QCborMap* QCborMap_fromVariantHash(struct miqt_map /* of struct miqt_string to QVariant* */ hash) { - QVariantHash hash_QMap; + QHash hash_QMap; hash_QMap.reserve(hash.len); struct miqt_string* hash_karr = static_cast(hash.keys); QVariant** hash_varr = static_cast(hash.values); @@ -305,7 +305,7 @@ QCborMap* QCborMap_fromJsonObject(QJsonObject* o) { } struct miqt_map /* of struct miqt_string to QVariant* */ QCborMap_toVariantMap(const QCborMap* self) { - QVariantMap _ret = self->toVariantMap(); + QMap _ret = self->toVariantMap(); // Convert QMap<> from C++ memory to manually-managed C memory struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); @@ -330,7 +330,7 @@ struct miqt_map /* of struct miqt_string to QVariant* */ QCborMap_toVariantMap( } struct miqt_map /* of struct miqt_string to QVariant* */ QCborMap_toVariantHash(const QCborMap* self) { - QVariantHash _ret = self->toVariantHash(); + QHash _ret = self->toVariantHash(); // Convert QMap<> from C++ memory to manually-managed C memory struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); @@ -375,7 +375,7 @@ void QCborMap__Iterator_operatorAssign(QCborMap__Iterator* self, QCborMap__Itera } struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap__Iterator_operatorMultiply(const QCborMap__Iterator* self) { - QCborMap::Iterator::value_type _ret = self->operator*(); + QPair _ret = self->operator*(); // Convert QPair<> from C++ memory to manually-managed C memory QCborValueConstRef** _first_arr = static_cast(malloc(sizeof(QCborValueConstRef*))); QCborValueRef** _second_arr = static_cast(malloc(sizeof(QCborValueRef*))); @@ -389,7 +389,7 @@ struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap_ } struct miqt_map /* tuple of QCborValueConstRef* and QCborValueRef* */ QCborMap__Iterator_operatorSubscript(const QCborMap__Iterator* self, ptrdiff_t j) { - QCborMap::Iterator::value_type _ret = self->operator[]((qsizetype)(j)); + QPair _ret = self->operator[]((qsizetype)(j)); // Convert QPair<> from C++ memory to manually-managed C memory QCborValueConstRef** _first_arr = static_cast(malloc(sizeof(QCborValueConstRef*))); QCborValueRef** _second_arr = static_cast(malloc(sizeof(QCborValueRef*))); @@ -528,7 +528,7 @@ void QCborMap__ConstIterator_operatorAssign(QCborMap__ConstIterator* self, QCbor } struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_operatorMultiply(const QCborMap__ConstIterator* self) { - QCborMap::ConstIterator::value_type _ret = self->operator*(); + QPair _ret = self->operator*(); // Convert QPair<> from C++ memory to manually-managed C memory QCborValueConstRef** _first_arr = static_cast(malloc(sizeof(QCborValueConstRef*))); QCborValueConstRef** _second_arr = static_cast(malloc(sizeof(QCborValueConstRef*))); @@ -542,7 +542,7 @@ struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCbo } struct miqt_map /* tuple of QCborValueConstRef* and QCborValueConstRef* */ QCborMap__ConstIterator_operatorSubscript(const QCborMap__ConstIterator* self, ptrdiff_t j) { - QCborMap::ConstIterator::value_type _ret = self->operator[]((qsizetype)(j)); + QPair _ret = self->operator[]((qsizetype)(j)); // Convert QPair<> from C++ memory to manually-managed C memory QCborValueConstRef** _first_arr = static_cast(malloc(sizeof(QCborValueConstRef*))); QCborValueConstRef** _second_arr = static_cast(malloc(sizeof(QCborValueConstRef*))); diff --git a/qt6/gen_qabstracteventdispatcher.cpp b/qt6/gen_qabstracteventdispatcher.cpp index 2f82dd4bd6..ef4388fbca 100644 --- a/qt6/gen_qabstracteventdispatcher.cpp +++ b/qt6/gen_qabstracteventdispatcher.cpp @@ -82,12 +82,12 @@ bool QAbstractEventDispatcher_unregisterTimers(QAbstractEventDispatcher* self, Q struct miqt_array /* of QAbstractEventDispatcher__TimerInfo* */ QAbstractEventDispatcher_registeredTimers(const QAbstractEventDispatcher* self, QObject* object) { QList _ret = self->registeredTimers(object); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractEventDispatcher__TimerInfo** _arr = static_cast(malloc(sizeof(QAbstractEventDispatcher__TimerInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractEventDispatcher__TimerInfo** _arr = static_cast(malloc(sizeof(QAbstractEventDispatcher__TimerInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QAbstractEventDispatcher::TimerInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qabstractitemdelegate.cpp b/qt6/gen_qabstractitemdelegate.cpp index 3b8100b8a6..ca2b3497be 100644 --- a/qt6/gen_qabstractitemdelegate.cpp +++ b/qt6/gen_qabstractitemdelegate.cpp @@ -468,12 +468,12 @@ bool QAbstractItemDelegate_helpEvent(QAbstractItemDelegate* self, QHelpEvent* ev struct miqt_array /* of int */ QAbstractItemDelegate_paintingRoles(const QAbstractItemDelegate* self) { QList _ret = self->paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -679,12 +679,12 @@ bool QAbstractItemDelegate_override_virtual_paintingRoles(void* self, intptr_t s struct miqt_array /* of int */ QAbstractItemDelegate_virtualbase_paintingRoles(const void* self) { QList _ret = static_cast(self)->QAbstractItemDelegate::paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qabstractitemmodel.cpp b/qt6/gen_qabstractitemmodel.cpp index 5389f94b44..ae8fc7ca36 100644 --- a/qt6/gen_qabstractitemmodel.cpp +++ b/qt6/gen_qabstractitemmodel.cpp @@ -734,13 +734,13 @@ class MiqtVirtualQAbstractItemModel final : public QAbstractItemModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QAbstractItemModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractItemModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -756,19 +756,19 @@ class MiqtVirtualQAbstractItemModel final : public QAbstractItemModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QAbstractItemModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractItemModel_mimeData(this, handle__mimeData, sigval1); @@ -1077,7 +1077,7 @@ class MiqtVirtualQAbstractItemModel final : public QAbstractItemModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QAbstractItemModel::match(start, role, value, hits, flags); } @@ -1093,7 +1093,7 @@ class MiqtVirtualQAbstractItemModel final : public QAbstractItemModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractItemModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1471,10 +1471,10 @@ bool QAbstractItemModel_clearItemData(QAbstractItemModel* self, QModelIndex* ind } struct miqt_array /* of struct miqt_string */ QAbstractItemModel_mimeTypes(const QAbstractItemModel* self) { - QStringList _ret = self->mimeTypes(); + QList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1485,13 +1485,13 @@ struct miqt_array /* of struct miqt_string */ QAbstractItemModel_mimeTypes(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QAbstractItemModel_mimeData(const QAbstractItemModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1588,14 +1588,14 @@ QModelIndex* QAbstractItemModel_buddy(const QAbstractItemModel* self, QModelInde } struct miqt_array /* of QModelIndex* */ QAbstractItemModel_match(const QAbstractItemModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1759,12 +1759,12 @@ void QAbstractItemModel_connect_dataChanged2(QAbstractItemModel* self, intptr_t QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QAbstractItemModel_dataChanged2(slot, sigval1, sigval2, sigval3); @@ -1785,12 +1785,12 @@ void QAbstractItemModel_connect_layoutChangedWithParents(QAbstractItemModel* sel QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), self, [=](const QList& parents) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; miqt_exec_callback_QAbstractItemModel_layoutChangedWithParents(slot, sigval1); @@ -1811,12 +1811,12 @@ void QAbstractItemModel_connect_layoutChanged2(QAbstractItemModel* self, intptr_ QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutChanged), self, [=](const QList& parents, QAbstractItemModel::LayoutChangeHint hint) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; QAbstractItemModel::LayoutChangeHint hint_ret = hint; @@ -1839,12 +1839,12 @@ void QAbstractItemModel_connect_layoutAboutToBeChangedWithParents(QAbstractItemM QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), self, [=](const QList& parents) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; miqt_exec_callback_QAbstractItemModel_layoutAboutToBeChangedWithParents(slot, sigval1); @@ -1865,12 +1865,12 @@ void QAbstractItemModel_connect_layoutAboutToBeChanged2(QAbstractItemModel* self QAbstractItemModel::connect(self, static_cast&, QAbstractItemModel::LayoutChangeHint)>(&QAbstractItemModel::layoutAboutToBeChanged), self, [=](const QList& parents, QAbstractItemModel::LayoutChangeHint hint) { const QList& parents_ret = parents; // Convert QList<> from C++ memory to manually-managed C memory - QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.length())); - for (size_t i = 0, e = parents_ret.length(); i < e; ++i) { + QPersistentModelIndex** parents_arr = static_cast(malloc(sizeof(QPersistentModelIndex*) * parents_ret.size())); + for (size_t i = 0, e = parents_ret.size(); i < e; ++i) { parents_arr[i] = new QPersistentModelIndex(parents_ret[i]); } struct miqt_array parents_out; - parents_out.len = parents_ret.length(); + parents_out.len = parents_ret.size(); parents_out.data = static_cast(parents_arr); struct miqt_array /* of QPersistentModelIndex* */ sigval1 = parents_out; QAbstractItemModel::LayoutChangeHint hint_ret = hint; @@ -2072,10 +2072,10 @@ bool QAbstractItemModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QAbstractItemModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QAbstractItemModel::mimeTypes(); + QList _ret = static_cast(self)->QAbstractItemModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2086,7 +2086,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractItemModel_virtualbase_mi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2102,7 +2102,7 @@ bool QAbstractItemModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractItemModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2335,14 +2335,14 @@ 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) { - QModelIndexList _ret = static_cast(self)->QAbstractItemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QAbstractItemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2578,7 +2578,7 @@ void QAbstractItemModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const v } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2771,13 +2771,13 @@ void QAbstractItemModel_protectedbase_changePersistentIndexList(bool* _dynamic_c } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2794,14 +2794,14 @@ struct miqt_array /* of QModelIndex* */ QAbstractItemModel_protectedbase_persis } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3305,13 +3305,13 @@ class MiqtVirtualQAbstractTableModel final : public QAbstractTableModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QAbstractTableModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractTableModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -3327,19 +3327,19 @@ class MiqtVirtualQAbstractTableModel final : public QAbstractTableModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QAbstractTableModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractTableModel_mimeData(this, handle__mimeData, sigval1); @@ -3607,7 +3607,7 @@ class MiqtVirtualQAbstractTableModel final : public QAbstractTableModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QAbstractTableModel::match(start, role, value, hits, flags); } @@ -3623,7 +3623,7 @@ class MiqtVirtualQAbstractTableModel final : public QAbstractTableModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractTableModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -4163,10 +4163,10 @@ bool QAbstractTableModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QAbstractTableModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QAbstractTableModel::mimeTypes(); + QList _ret = static_cast(self)->QAbstractTableModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -4177,7 +4177,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractTableModel_virtualbase_m _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -4193,7 +4193,7 @@ bool QAbstractTableModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractTableModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -4397,14 +4397,14 @@ 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) { - QModelIndexList _ret = static_cast(self)->QAbstractTableModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QAbstractTableModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -4629,7 +4629,7 @@ void QAbstractTableModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -4822,13 +4822,13 @@ void QAbstractTableModel_protectedbase_changePersistentIndexList(bool* _dynamic_ } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -4845,14 +4845,14 @@ struct miqt_array /* of QModelIndex* */ QAbstractTableModel_protectedbase_persi } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -5169,13 +5169,13 @@ class MiqtVirtualQAbstractListModel final : public QAbstractListModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QAbstractListModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractListModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -5191,19 +5191,19 @@ class MiqtVirtualQAbstractListModel final : public QAbstractListModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QAbstractListModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractListModel_mimeData(this, handle__mimeData, sigval1); @@ -5471,7 +5471,7 @@ class MiqtVirtualQAbstractListModel final : public QAbstractListModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QAbstractListModel::match(start, role, value, hits, flags); } @@ -5487,7 +5487,7 @@ class MiqtVirtualQAbstractListModel final : public QAbstractListModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractListModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -6017,10 +6017,10 @@ bool QAbstractListModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QAbstractListModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QAbstractListModel::mimeTypes(); + QList _ret = static_cast(self)->QAbstractListModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -6031,7 +6031,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractListModel_virtualbase_mi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -6047,7 +6047,7 @@ bool QAbstractListModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractListModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -6251,14 +6251,14 @@ 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) { - QModelIndexList _ret = static_cast(self)->QAbstractListModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QAbstractListModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -6483,7 +6483,7 @@ void QAbstractListModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const v } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -6676,13 +6676,13 @@ void QAbstractListModel_protectedbase_changePersistentIndexList(bool* _dynamic_c } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -6699,14 +6699,14 @@ struct miqt_array /* of QModelIndex* */ QAbstractListModel_protectedbase_persis } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qabstractitemview.cpp b/qt6/gen_qabstractitemview.cpp index 526c7c0c85..c6faa12417 100644 --- a/qt6/gen_qabstractitemview.cpp +++ b/qt6/gen_qabstractitemview.cpp @@ -425,12 +425,12 @@ class MiqtVirtualQAbstractItemView final : public QAbstractItemView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QAbstractItemView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -791,13 +791,13 @@ class MiqtVirtualQAbstractItemView final : public QAbstractItemView { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QAbstractItemView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractItemView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -2675,14 +2675,14 @@ bool QAbstractItemView_override_virtual_selectedIndexes(void* self, intptr_t slo } struct miqt_array /* of QModelIndex* */ QAbstractItemView_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QAbstractItemView::selectedIndexes(); + QList _ret = static_cast(self)->QAbstractItemView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qabstractproxymodel.cpp b/qt6/gen_qabstractproxymodel.cpp index 3b5b9daf4d..542a004b80 100644 --- a/qt6/gen_qabstractproxymodel.cpp +++ b/qt6/gen_qabstractproxymodel.cpp @@ -514,19 +514,19 @@ class MiqtVirtualQAbstractProxyModel final : public QAbstractProxyModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QAbstractProxyModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QAbstractProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -585,13 +585,13 @@ class MiqtVirtualQAbstractProxyModel final : public QAbstractProxyModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QAbstractProxyModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QAbstractProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -854,7 +854,7 @@ class MiqtVirtualQAbstractProxyModel final : public QAbstractProxyModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QAbstractProxyModel::match(start, role, value, hits, flags); } @@ -870,7 +870,7 @@ class MiqtVirtualQAbstractProxyModel final : public QAbstractProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QAbstractProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1212,7 +1212,7 @@ QModelIndex* QAbstractProxyModel_sibling(const QAbstractProxyModel* self, int ro } QMimeData* QAbstractProxyModel_mimeData(const QAbstractProxyModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1230,10 +1230,10 @@ bool QAbstractProxyModel_dropMimeData(QAbstractProxyModel* self, QMimeData* data } struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_mimeTypes(const QAbstractProxyModel* self) { - QStringList _ret = self->mimeTypes(); + QList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1244,7 +1244,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_mimeTypes(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1636,7 +1636,7 @@ bool QAbstractProxyModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QAbstractProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1684,10 +1684,10 @@ bool QAbstractProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QAbstractProxyModel::mimeTypes(); + QList _ret = static_cast(self)->QAbstractProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1698,7 +1698,7 @@ struct miqt_array /* of struct miqt_string */ QAbstractProxyModel_virtualbase_m _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1901,14 +1901,14 @@ 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) { - QModelIndexList _ret = static_cast(self)->QAbstractProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QAbstractProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2069,7 +2069,7 @@ void QAbstractProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2262,13 +2262,13 @@ void QAbstractProxyModel_protectedbase_changePersistentIndexList(bool* _dynamic_ } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2285,14 +2285,14 @@ struct miqt_array /* of QModelIndex* */ QAbstractProxyModel_protectedbase_persi } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qabstractscrollarea.cpp b/qt6/gen_qabstractscrollarea.cpp index 30cd073e09..a673886b41 100644 --- a/qt6/gen_qabstractscrollarea.cpp +++ b/qt6/gen_qabstractscrollarea.cpp @@ -1082,14 +1082,14 @@ void QAbstractScrollArea_addScrollBarWidget(QAbstractScrollArea* self, QWidget* } struct miqt_array /* of QWidget* */ QAbstractScrollArea_scrollBarWidgets(QAbstractScrollArea* self, int alignment) { - QWidgetList _ret = self->scrollBarWidgets(static_cast(alignment)); + QList _ret = self->scrollBarWidgets(static_cast(alignment)); // Convert QList<> from C++ memory to manually-managed C memory - QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qaccessible.cpp b/qt6/gen_qaccessible.cpp index 640b3cbfb1..e35b30b6cf 100644 --- a/qt6/gen_qaccessible.cpp +++ b/qt6/gen_qaccessible.cpp @@ -62,10 +62,10 @@ 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) { - QList> _ret = self->relations(static_cast(match)); + QList>> _ret = self->relations(static_cast(match)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair> _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory QAccessibleInterface** _lv_first_arr = static_cast(malloc(sizeof(QAccessibleInterface*))); @@ -80,7 +80,7 @@ struct miqt_array /* of struct miqt_map tuple of QAccessibleInterface* and int _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -348,27 +348,27 @@ bool QAccessibleTableCellInterface_isSelected(const QAccessibleTableCellInterfac } struct miqt_array /* of QAccessibleInterface* */ QAccessibleTableCellInterface_columnHeaderCells(const QAccessibleTableCellInterface* self) { - QList _ret = self->columnHeaderCells(); + QList _ret = self->columnHeaderCells(); // Convert QList<> from C++ memory to manually-managed C memory - QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QAccessibleInterface* */ QAccessibleTableCellInterface_rowHeaderCells(const QAccessibleTableCellInterface* self) { - QList _ret = self->rowHeaderCells(); + QList _ret = self->rowHeaderCells(); // Convert QList<> from C++ memory to manually-managed C memory - QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -418,14 +418,14 @@ int QAccessibleTableInterface_selectedCellCount(const QAccessibleTableInterface* } struct miqt_array /* of QAccessibleInterface* */ QAccessibleTableInterface_selectedCells(const QAccessibleTableInterface* self) { - QList _ret = self->selectedCells(); + QList _ret = self->selectedCells(); // Convert QList<> from C++ memory to manually-managed C memory - QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAccessibleInterface** _arr = static_cast(malloc(sizeof(QAccessibleInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -471,12 +471,12 @@ int QAccessibleTableInterface_rowCount(const QAccessibleTableInterface* self) { struct miqt_array /* of int */ QAccessibleTableInterface_selectedColumns(const QAccessibleTableInterface* self) { QList _ret = self->selectedColumns(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -484,12 +484,12 @@ struct miqt_array /* of int */ QAccessibleTableInterface_selectedColumns(const struct miqt_array /* of int */ QAccessibleTableInterface_selectedRows(const QAccessibleTableInterface* self) { QList _ret = self->selectedRows(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -538,10 +538,10 @@ struct miqt_string QAccessibleActionInterface_tr(const char* sourceText) { } struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_actionNames(const QAccessibleActionInterface* self) { - QStringList _ret = self->actionNames(); + QList _ret = self->actionNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -552,7 +552,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_action _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -588,10 +588,10 @@ void QAccessibleActionInterface_doAction(QAccessibleActionInterface* self, struc struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_keyBindingsForAction(const QAccessibleActionInterface* self, struct miqt_string actionName) { QString actionName_QString = QString::fromUtf8(actionName.data, actionName.len); - QStringList _ret = self->keyBindingsForAction(actionName_QString); + QList _ret = self->keyBindingsForAction(actionName_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -602,7 +602,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleActionInterface_keyBin _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qaccessiblewidget.cpp b/qt6/gen_qaccessiblewidget.cpp index e3d1c599b0..42710a6aa4 100644 --- a/qt6/gen_qaccessiblewidget.cpp +++ b/qt6/gen_qaccessiblewidget.cpp @@ -59,10 +59,10 @@ int QAccessibleWidget_indexOfChild(const QAccessibleWidget* self, QAccessibleInt } struct miqt_array /* of struct miqt_map tuple of QAccessibleInterface* and int */ QAccessibleWidget_relations(const QAccessibleWidget* self, int match) { - QList> _ret = self->relations(static_cast(match)); + QList>> _ret = self->relations(static_cast(match)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of QAccessibleInterface* and int */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of QAccessibleInterface* and int */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair> _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory QAccessibleInterface** _lv_first_arr = static_cast(malloc(sizeof(QAccessibleInterface*))); @@ -77,7 +77,7 @@ struct miqt_array /* of struct miqt_map tuple of QAccessibleInterface* and int _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -131,10 +131,10 @@ void* QAccessibleWidget_interfaceCast(QAccessibleWidget* self, int t) { } struct miqt_array /* of struct miqt_string */ QAccessibleWidget_actionNames(const QAccessibleWidget* self) { - QStringList _ret = self->actionNames(); + QList _ret = self->actionNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -145,7 +145,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleWidget_actionNames(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -157,10 +157,10 @@ void QAccessibleWidget_doAction(QAccessibleWidget* self, struct miqt_string acti 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); + QList _ret = self->keyBindingsForAction(actionName_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -171,7 +171,7 @@ struct miqt_array /* of struct miqt_string */ QAccessibleWidget_keyBindingsForA _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qaction.cpp b/qt6/gen_qaction.cpp index 8e5464d5a3..ebf982754d 100644 --- a/qt6/gen_qaction.cpp +++ b/qt6/gen_qaction.cpp @@ -233,14 +233,14 @@ struct miqt_string QAction_tr(const char* s) { } struct miqt_array /* of QObject* */ QAction_associatedObjects(const QAction* self) { - QList _ret = self->associatedObjects(); + QList _ret = self->associatedObjects(); // Convert QList<> from C++ memory to manually-managed C memory - QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -383,12 +383,12 @@ void QAction_setShortcutsWithShortcuts(QAction* self, int shortcuts) { struct miqt_array /* of QKeySequence* */ QAction_shortcuts(const QAction* self) { QList _ret = self->shortcuts(); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qactiongroup.cpp b/qt6/gen_qactiongroup.cpp index bda58dcd5e..c3ff4e070c 100644 --- a/qt6/gen_qactiongroup.cpp +++ b/qt6/gen_qactiongroup.cpp @@ -213,14 +213,14 @@ void QActionGroup_removeAction(QActionGroup* self, QAction* a) { } struct miqt_array /* of QAction* */ QActionGroup_actions(const QActionGroup* self) { - QList _ret = self->actions(); + QList _ret = self->actions(); // Convert QList<> from C++ memory to manually-managed C memory - QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qapplication.cpp b/qt6/gen_qapplication.cpp index 56f8d0ef3b..6a5ebdf935 100644 --- a/qt6/gen_qapplication.cpp +++ b/qt6/gen_qapplication.cpp @@ -269,27 +269,27 @@ QFontMetrics* QApplication_fontMetrics() { } struct miqt_array /* of QWidget* */ QApplication_allWidgets() { - QWidgetList _ret = QApplication::allWidgets(); + QList _ret = QApplication::allWidgets(); // Convert QList<> from C++ memory to manually-managed C memory - QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QWidget* */ QApplication_topLevelWidgets() { - QWidgetList _ret = QApplication::topLevelWidgets(); + QList _ret = QApplication::topLevelWidgets(); // Convert QList<> from C++ memory to manually-managed C memory - QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qarraydata.cpp b/qt6/gen_qarraydata.cpp index d91dcbcc30..9bba8837e1 100644 --- a/qt6/gen_qarraydata.cpp +++ b/qt6/gen_qarraydata.cpp @@ -49,7 +49,7 @@ ptrdiff_t QArrayData_detachCapacity(const QArrayData* self, ptrdiff_t newSize) { } struct miqt_map /* tuple of QArrayData* and void* */ QArrayData_reallocateUnaligned(QArrayData* data, void* dataPointer, ptrdiff_t objectSize, ptrdiff_t newCapacity, int option) { - QPair _ret = QArrayData::reallocateUnaligned(data, dataPointer, (qsizetype)(objectSize), (qsizetype)(newCapacity), static_cast(option)); + QPair _ret = QArrayData::reallocateUnaligned(data, dataPointer, (qsizetype)(objectSize), (qsizetype)(newCapacity), static_cast(option)); // Convert QPair<> from C++ memory to manually-managed C memory QArrayData** _first_arr = static_cast(malloc(sizeof(QArrayData*))); void** _second_arr = static_cast(malloc(sizeof(void*))); diff --git a/qt6/gen_qbrush.cpp b/qt6/gen_qbrush.cpp index d7f7023834..15e2c18555 100644 --- a/qt6/gen_qbrush.cpp +++ b/qt6/gen_qbrush.cpp @@ -198,7 +198,7 @@ void QGradient_setColorAt(QGradient* self, double pos, QColor* color) { } void QGradient_setStops(QGradient* self, struct miqt_array /* of struct miqt_map tuple of double and QColor* */ stops) { - QGradientStops stops_QList; + QList> stops_QList; stops_QList.reserve(stops.len); struct miqt_map /* tuple of double and QColor* */ * stops_arr = static_cast(stops.data); for(size_t i = 0; i < stops.len; ++i) { @@ -213,10 +213,10 @@ void QGradient_setStops(QGradient* self, struct miqt_array /* of struct miqt_map } struct miqt_array /* of struct miqt_map tuple of double and QColor* */ QGradient_stops(const QGradient* self) { - QGradientStops _ret = self->stops(); + QList> _ret = self->stops(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QColor* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QColor* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QColor* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QColor* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -230,7 +230,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QColor* */ QGrad _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qbuttongroup.cpp b/qt6/gen_qbuttongroup.cpp index 1d6968d0c6..360876c3d9 100644 --- a/qt6/gen_qbuttongroup.cpp +++ b/qt6/gen_qbuttongroup.cpp @@ -221,14 +221,14 @@ void QButtonGroup_removeButton(QButtonGroup* self, QAbstractButton* param1) { } struct miqt_array /* of QAbstractButton* */ QButtonGroup_buttons(const QButtonGroup* self) { - QList _ret = self->buttons(); + QList _ret = self->buttons(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcalendar.cpp b/qt6/gen_qcalendar.cpp index dbb56451b2..c6f6b3373b 100644 --- a/qt6/gen_qcalendar.cpp +++ b/qt6/gen_qcalendar.cpp @@ -167,10 +167,10 @@ struct miqt_string QCalendar_standaloneWeekDayName(const QCalendar* self, QLocal } struct miqt_array /* of struct miqt_string */ QCalendar_availableCalendars() { - QStringList _ret = QCalendar::availableCalendars(); + QList _ret = QCalendar::availableCalendars(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -181,7 +181,7 @@ struct miqt_array /* of struct miqt_string */ QCalendar_availableCalendars() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcolor.cpp b/qt6/gen_qcolor.cpp index 9d28aff965..0b71ebfcd4 100644 --- a/qt6/gen_qcolor.cpp +++ b/qt6/gen_qcolor.cpp @@ -95,10 +95,10 @@ void QColor_setNamedColor(QColor* self, struct miqt_string name) { } struct miqt_array /* of struct miqt_string */ QColor_colorNames() { - QStringList _ret = QColor::colorNames(); + QList _ret = QColor::colorNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -109,7 +109,7 @@ struct miqt_array /* of struct miqt_string */ QColor_colorNames() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcolormap.cpp b/qt6/gen_qcolormap.cpp index 108af0309b..fff7b19d9d 100644 --- a/qt6/gen_qcolormap.cpp +++ b/qt6/gen_qcolormap.cpp @@ -57,12 +57,12 @@ QColor* QColormap_colorAt(const QColormap* self, unsigned int pixel) { struct miqt_array /* of QColor* */ QColormap_colormap(const QColormap* self) { const QList _ret = self->colormap(); // Convert QList<> from C++ memory to manually-managed C memory - QColor** _arr = static_cast(malloc(sizeof(QColor*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QColor** _arr = static_cast(malloc(sizeof(QColor*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QColor(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcolumnview.cpp b/qt6/gen_qcolumnview.cpp index f2eb44ca09..b5e71f4521 100644 --- a/qt6/gen_qcolumnview.cpp +++ b/qt6/gen_qcolumnview.cpp @@ -645,12 +645,12 @@ class MiqtVirtualQColumnView final : public QColumnView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QColumnView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -875,13 +875,13 @@ class MiqtVirtualQColumnView final : public QColumnView { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QColumnView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QColumnView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1909,12 +1909,12 @@ void QColumnView_setColumnWidths(QColumnView* self, struct miqt_array /* of int struct miqt_array /* of int */ QColumnView_columnWidths(const QColumnView* self) { QList _ret = self->columnWidths(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2505,14 +2505,14 @@ bool QColumnView_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QColumnView_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QColumnView::selectedIndexes(); + QList _ret = static_cast(self)->QColumnView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcombobox.cpp b/qt6/gen_qcombobox.cpp index 200002bbf0..375964ef33 100644 --- a/qt6/gen_qcombobox.cpp +++ b/qt6/gen_qcombobox.cpp @@ -1233,7 +1233,7 @@ void QComboBox_addItem2(QComboBox* self, QIcon* icon, struct miqt_string text) { } void QComboBox_addItems(QComboBox* self, struct miqt_array /* of struct miqt_string */ texts) { - QStringList texts_QList; + QList texts_QList; texts_QList.reserve(texts.len); struct miqt_string* texts_arr = static_cast(texts.data); for(size_t i = 0; i < texts.len; ++i) { @@ -1254,7 +1254,7 @@ void QComboBox_insertItem2(QComboBox* self, int index, QIcon* icon, struct miqt_ } void QComboBox_insertItems(QComboBox* self, int index, struct miqt_array /* of struct miqt_string */ texts) { - QStringList texts_QList; + QList texts_QList; texts_QList.reserve(texts.len); struct miqt_string* texts_arr = static_cast(texts.data); for(size_t i = 0; i < texts.len; ++i) { diff --git a/qt6/gen_qcommandlineoption.cpp b/qt6/gen_qcommandlineoption.cpp index 19ca40072c..f6ce99b99c 100644 --- a/qt6/gen_qcommandlineoption.cpp +++ b/qt6/gen_qcommandlineoption.cpp @@ -20,7 +20,7 @@ QCommandLineOption* QCommandLineOption_new(struct miqt_string name) { } QCommandLineOption* QCommandLineOption_new2(struct miqt_array /* of struct miqt_string */ names) { - QStringList names_QList; + QList names_QList; names_QList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { @@ -37,7 +37,7 @@ QCommandLineOption* QCommandLineOption_new3(struct miqt_string name, struct miqt } QCommandLineOption* QCommandLineOption_new4(struct miqt_array /* of struct miqt_string */ names, struct miqt_string description) { - QStringList names_QList; + QList names_QList; names_QList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { @@ -68,7 +68,7 @@ QCommandLineOption* QCommandLineOption_new7(struct miqt_string name, struct miqt } QCommandLineOption* QCommandLineOption_new8(struct miqt_array /* of struct miqt_string */ names, struct miqt_string description, struct miqt_string valueName) { - QStringList names_QList; + QList names_QList; names_QList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { @@ -81,7 +81,7 @@ QCommandLineOption* QCommandLineOption_new8(struct miqt_array /* of struct miqt_ } QCommandLineOption* QCommandLineOption_new9(struct miqt_array /* of struct miqt_string */ names, struct miqt_string description, struct miqt_string valueName, struct miqt_string defaultValue) { - QStringList names_QList; + QList names_QList; names_QList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { @@ -103,10 +103,10 @@ void QCommandLineOption_swap(QCommandLineOption* self, QCommandLineOption* other } struct miqt_array /* of struct miqt_string */ QCommandLineOption_names(const QCommandLineOption* self) { - QStringList _ret = self->names(); + QList _ret = self->names(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -117,7 +117,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineOption_names(const QC _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -160,7 +160,7 @@ void QCommandLineOption_setDefaultValue(QCommandLineOption* self, struct miqt_st } void QCommandLineOption_setDefaultValues(QCommandLineOption* self, struct miqt_array /* of struct miqt_string */ defaultValues) { - QStringList defaultValues_QList; + QList defaultValues_QList; defaultValues_QList.reserve(defaultValues.len); struct miqt_string* defaultValues_arr = static_cast(defaultValues.data); for(size_t i = 0; i < defaultValues.len; ++i) { @@ -171,10 +171,10 @@ void QCommandLineOption_setDefaultValues(QCommandLineOption* self, struct miqt_a } struct miqt_array /* of struct miqt_string */ QCommandLineOption_defaultValues(const QCommandLineOption* self) { - QStringList _ret = self->defaultValues(); + QList _ret = self->defaultValues(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -185,7 +185,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineOption_defaultValues( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcommandlineparser.cpp b/qt6/gen_qcommandlineparser.cpp index 86f9a7d958..9781242091 100644 --- a/qt6/gen_qcommandlineparser.cpp +++ b/qt6/gen_qcommandlineparser.cpp @@ -88,7 +88,7 @@ void QCommandLineParser_clearPositionalArguments(QCommandLineParser* self) { } void QCommandLineParser_process(QCommandLineParser* self, struct miqt_array /* of struct miqt_string */ arguments) { - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -103,7 +103,7 @@ void QCommandLineParser_processWithApp(QCommandLineParser* self, QCoreApplicatio } bool QCommandLineParser_parse(QCommandLineParser* self, struct miqt_array /* of struct miqt_string */ arguments) { - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -143,10 +143,10 @@ struct miqt_string QCommandLineParser_value(const QCommandLineParser* self, stru struct miqt_array /* of struct miqt_string */ QCommandLineParser_values(const QCommandLineParser* self, struct miqt_string name) { QString name_QString = QString::fromUtf8(name.data, name.len); - QStringList _ret = self->values(name_QString); + QList _ret = self->values(name_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -157,7 +157,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_values(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -178,10 +178,10 @@ struct miqt_string QCommandLineParser_valueWithOption(const QCommandLineParser* } struct miqt_array /* of struct miqt_string */ QCommandLineParser_valuesWithOption(const QCommandLineParser* self, QCommandLineOption* option) { - QStringList _ret = self->values(*option); + QList _ret = self->values(*option); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -192,16 +192,16 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_valuesWithOpti _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QCommandLineParser_positionalArguments(const QCommandLineParser* self) { - QStringList _ret = self->positionalArguments(); + QList _ret = self->positionalArguments(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -212,16 +212,16 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_positionalArgu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QCommandLineParser_optionNames(const QCommandLineParser* self) { - QStringList _ret = self->optionNames(); + QList _ret = self->optionNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -232,16 +232,16 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_optionNames(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QCommandLineParser_unknownOptionNames(const QCommandLineParser* self) { - QStringList _ret = self->unknownOptionNames(); + QList _ret = self->unknownOptionNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -252,7 +252,7 @@ struct miqt_array /* of struct miqt_string */ QCommandLineParser_unknownOptionN _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcompleter.cpp b/qt6/gen_qcompleter.cpp index dda4760864..f1210eef22 100644 --- a/qt6/gen_qcompleter.cpp +++ b/qt6/gen_qcompleter.cpp @@ -43,10 +43,10 @@ class MiqtVirtualQCompleter final : public QCompleter { MiqtVirtualQCompleter(): QCompleter() {} MiqtVirtualQCompleter(QAbstractItemModel* model): QCompleter(model) {} - MiqtVirtualQCompleter(const QStringList& completions): QCompleter(completions) {} + MiqtVirtualQCompleter(const QList& completions): QCompleter(completions) {} MiqtVirtualQCompleter(QObject* parent): QCompleter(parent) {} MiqtVirtualQCompleter(QAbstractItemModel* model, QObject* parent): QCompleter(model, parent) {} - MiqtVirtualQCompleter(const QStringList& completions, QObject* parent): QCompleter(completions, parent) {} + MiqtVirtualQCompleter(const QList& completions, QObject* parent): QCompleter(completions, parent) {} virtual ~MiqtVirtualQCompleter() override = default; @@ -73,7 +73,7 @@ class MiqtVirtualQCompleter final : public QCompleter { intptr_t handle__splitPath = 0; // Subclass to allow providing a Go implementation - virtual QStringList splitPath(const QString& path) const override { + virtual QList splitPath(const QString& path) const override { if (handle__splitPath == 0) { return QCompleter::splitPath(path); } @@ -87,7 +87,7 @@ class MiqtVirtualQCompleter final : public QCompleter { memcpy(path_ms.data, path_b.data(), path_ms.len); struct miqt_string sigval1 = path_ms; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QCompleter_splitPath(this, handle__splitPath, sigval1); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -237,7 +237,7 @@ QCompleter* QCompleter_new2(QAbstractItemModel* model) { } QCompleter* QCompleter_new3(struct miqt_array /* of struct miqt_string */ completions) { - QStringList completions_QList; + QList completions_QList; completions_QList.reserve(completions.len); struct miqt_string* completions_arr = static_cast(completions.data); for(size_t i = 0; i < completions.len; ++i) { @@ -256,7 +256,7 @@ QCompleter* QCompleter_new5(QAbstractItemModel* model, QObject* parent) { } QCompleter* QCompleter_new6(struct miqt_array /* of struct miqt_string */ completions, QObject* parent) { - QStringList completions_QList; + QList completions_QList; completions_QList.reserve(completions.len); struct miqt_string* completions_arr = static_cast(completions.data); for(size_t i = 0; i < completions.len; ++i) { @@ -445,10 +445,10 @@ struct miqt_string QCompleter_pathFromIndex(const QCompleter* self, QModelIndex* struct miqt_array /* of struct miqt_string */ QCompleter_splitPath(const QCompleter* self, struct miqt_string path) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList _ret = self->splitPath(path_QString); + QList _ret = self->splitPath(path_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -459,7 +459,7 @@ struct miqt_array /* of struct miqt_string */ QCompleter_splitPath(const QCompl _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -587,10 +587,10 @@ bool QCompleter_override_virtual_splitPath(void* self, intptr_t slot) { struct miqt_array /* of struct miqt_string */ QCompleter_virtualbase_splitPath(const void* self, struct miqt_string path) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList _ret = static_cast(self)->QCompleter::splitPath(path_QString); + QList _ret = static_cast(self)->QCompleter::splitPath(path_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -601,7 +601,7 @@ struct miqt_array /* of struct miqt_string */ QCompleter_virtualbase_splitPath( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qconcatenatetablesproxymodel.cpp b/qt6/gen_qconcatenatetablesproxymodel.cpp index 8817e6ede0..75cb10bc09 100644 --- a/qt6/gen_qconcatenatetablesproxymodel.cpp +++ b/qt6/gen_qconcatenatetablesproxymodel.cpp @@ -295,13 +295,13 @@ class MiqtVirtualQConcatenateTablesProxyModel final : public QConcatenateTablesP intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QConcatenateTablesProxyModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QConcatenateTablesProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -317,19 +317,19 @@ class MiqtVirtualQConcatenateTablesProxyModel final : public QConcatenateTablesP intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QConcatenateTablesProxyModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QConcatenateTablesProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -716,7 +716,7 @@ class MiqtVirtualQConcatenateTablesProxyModel final : public QConcatenateTablesP intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QConcatenateTablesProxyModel::match(start, role, value, hits, flags); } @@ -732,7 +732,7 @@ class MiqtVirtualQConcatenateTablesProxyModel final : public QConcatenateTablesP Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QConcatenateTablesProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1014,14 +1014,14 @@ struct miqt_string QConcatenateTablesProxyModel_tr(const char* s) { } struct miqt_array /* of QAbstractItemModel* */ QConcatenateTablesProxyModel_sourceModels(const QConcatenateTablesProxyModel* self) { - QList _ret = self->sourceModels(); + QList _ret = self->sourceModels(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractItemModel** _arr = static_cast(malloc(sizeof(QAbstractItemModel*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractItemModel** _arr = static_cast(malloc(sizeof(QAbstractItemModel*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1104,10 +1104,10 @@ int QConcatenateTablesProxyModel_columnCount(const QConcatenateTablesProxyModel* } struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_mimeTypes(const QConcatenateTablesProxyModel* self) { - QStringList _ret = self->mimeTypes(); + QList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1118,13 +1118,13 @@ struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_mime _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QConcatenateTablesProxyModel_mimeData(const QConcatenateTablesProxyModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1339,10 +1339,10 @@ bool QConcatenateTablesProxyModel_override_virtual_mimeTypes(void* self, intptr_ } struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QConcatenateTablesProxyModel::mimeTypes(); + QList _ret = static_cast(self)->QConcatenateTablesProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1353,7 +1353,7 @@ struct miqt_array /* of struct miqt_string */ QConcatenateTablesProxyModel_virt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1369,7 +1369,7 @@ bool QConcatenateTablesProxyModel_override_virtual_mimeData(void* self, intptr_t } QMimeData* QConcatenateTablesProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1657,14 +1657,14 @@ bool QConcatenateTablesProxyModel_override_virtual_match(void* self, intptr_t sl } struct miqt_array /* of QModelIndex* */ QConcatenateTablesProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QConcatenateTablesProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QConcatenateTablesProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1875,7 +1875,7 @@ void QConcatenateTablesProxyModel_protectedbase_encodeData(bool* _dynamic_cast_o } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2068,13 +2068,13 @@ void QConcatenateTablesProxyModel_protectedbase_changePersistentIndexList(bool* } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2091,14 +2091,14 @@ struct miqt_array /* of QModelIndex* */ QConcatenateTablesProxyModel_protectedb } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qcoreapplication.cpp b/qt6/gen_qcoreapplication.cpp index 04d34e187a..1a95d5e2a9 100644 --- a/qt6/gen_qcoreapplication.cpp +++ b/qt6/gen_qcoreapplication.cpp @@ -225,10 +225,10 @@ struct miqt_string QCoreApplication_tr(const char* s) { } struct miqt_array /* of struct miqt_string */ QCoreApplication_arguments() { - QStringList _ret = QCoreApplication::arguments(); + QList _ret = QCoreApplication::arguments(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -239,7 +239,7 @@ struct miqt_array /* of struct miqt_string */ QCoreApplication_arguments() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -404,7 +404,7 @@ long long QCoreApplication_applicationPid() { } void QCoreApplication_setLibraryPaths(struct miqt_array /* of struct miqt_string */ libraryPaths) { - QStringList libraryPaths_QList; + QList libraryPaths_QList; libraryPaths_QList.reserve(libraryPaths.len); struct miqt_string* libraryPaths_arr = static_cast(libraryPaths.data); for(size_t i = 0; i < libraryPaths.len; ++i) { @@ -415,10 +415,10 @@ void QCoreApplication_setLibraryPaths(struct miqt_array /* of struct miqt_string } struct miqt_array /* of struct miqt_string */ QCoreApplication_libraryPaths() { - QStringList _ret = QCoreApplication::libraryPaths(); + QList _ret = QCoreApplication::libraryPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -429,7 +429,7 @@ struct miqt_array /* of struct miqt_string */ QCoreApplication_libraryPaths() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qdialogbuttonbox.cpp b/qt6/gen_qdialogbuttonbox.cpp index 3f9bb6205c..14455d6474 100644 --- a/qt6/gen_qdialogbuttonbox.cpp +++ b/qt6/gen_qdialogbuttonbox.cpp @@ -1006,14 +1006,14 @@ void QDialogButtonBox_clear(QDialogButtonBox* self) { } struct miqt_array /* of QAbstractButton* */ QDialogButtonBox_buttons(const QDialogButtonBox* self) { - QList _ret = self->buttons(); + QList _ret = self->buttons(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qdir.cpp b/qt6/gen_qdir.cpp index 69d9c4ecc6..171917a375 100644 --- a/qt6/gen_qdir.cpp +++ b/qt6/gen_qdir.cpp @@ -95,7 +95,7 @@ struct miqt_string QDir_canonicalPath(const QDir* self) { void QDir_setSearchPaths(struct miqt_string prefix, struct miqt_array /* of struct miqt_string */ searchPaths) { QString prefix_QString = QString::fromUtf8(prefix.data, prefix.len); - QStringList searchPaths_QList; + QList searchPaths_QList; searchPaths_QList.reserve(searchPaths.len); struct miqt_string* searchPaths_arr = static_cast(searchPaths.data); for(size_t i = 0; i < searchPaths.len; ++i) { @@ -113,10 +113,10 @@ void QDir_addSearchPath(struct miqt_string prefix, struct miqt_string path) { struct miqt_array /* of struct miqt_string */ QDir_searchPaths(struct miqt_string prefix) { QString prefix_QString = QString::fromUtf8(prefix.data, prefix.len); - QStringList _ret = QDir::searchPaths(prefix_QString); + QList _ret = QDir::searchPaths(prefix_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -127,7 +127,7 @@ struct miqt_array /* of struct miqt_string */ QDir_searchPaths(struct miqt_stri _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -213,10 +213,10 @@ bool QDir_cdUp(QDir* self) { } struct miqt_array /* of struct miqt_string */ QDir_nameFilters(const QDir* self) { - QStringList _ret = self->nameFilters(); + QList _ret = self->nameFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -227,13 +227,13 @@ struct miqt_array /* of struct miqt_string */ QDir_nameFilters(const QDir* self _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QDir_setNameFilters(QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters) { - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { @@ -283,10 +283,10 @@ struct miqt_string QDir_operatorSubscript(const QDir* self, int param1) { struct miqt_array /* of struct miqt_string */ QDir_nameFiltersFromString(struct miqt_string nameFilter) { QString nameFilter_QString = QString::fromUtf8(nameFilter.data, nameFilter.len); - QStringList _ret = QDir::nameFiltersFromString(nameFilter_QString); + QList _ret = QDir::nameFiltersFromString(nameFilter_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -297,16 +297,16 @@ struct miqt_array /* of struct miqt_string */ QDir_nameFiltersFromString(struct _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryList(const QDir* self) { - QStringList _ret = self->entryList(); + QList _ret = self->entryList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -317,23 +317,23 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList(const QDir* self) _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryListWithNameFilters(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters) { - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); nameFilters_QList.push_back(nameFilters_arr_i_QString); } - QStringList _ret = self->entryList(nameFilters_QList); + QList _ret = self->entryList(nameFilters_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -344,40 +344,40 @@ struct miqt_array /* of struct miqt_string */ QDir_entryListWithNameFilters(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoList(const QDir* self) { - QFileInfoList _ret = self->entryInfoList(); + QList _ret = self->entryInfoList(); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoListWithNameFilters(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters) { - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); nameFilters_QList.push_back(nameFilters_arr_i_QString); } - QFileInfoList _ret = self->entryInfoList(nameFilters_QList); + QList _ret = self->entryInfoList(nameFilters_QList); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -470,14 +470,14 @@ bool QDir_existsWithName(const QDir* self, struct miqt_string name) { } struct miqt_array /* of QFileInfo* */ QDir_drives() { - QFileInfoList _ret = QDir::drives(); + QList _ret = QDir::drives(); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -556,7 +556,7 @@ struct miqt_string QDir_tempPath() { } bool QDir_match(struct miqt_array /* of struct miqt_string */ filters, struct miqt_string fileName) { - QStringList filters_QList; + QList filters_QList; filters_QList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { @@ -594,10 +594,10 @@ bool QDir_isEmptyWithFilters(const QDir* self, int filters) { } struct miqt_array /* of struct miqt_string */ QDir_entryListWithFilters(const QDir* self, int filters) { - QStringList _ret = self->entryList(static_cast(filters)); + QList _ret = self->entryList(static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -608,16 +608,16 @@ struct miqt_array /* of struct miqt_string */ QDir_entryListWithFilters(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryList2(const QDir* self, int filters, int sort) { - QStringList _ret = self->entryList(static_cast(filters), static_cast(sort)); + QList _ret = self->entryList(static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -628,23 +628,23 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList2(const QDir* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryList3(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters) { - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); nameFilters_QList.push_back(nameFilters_arr_i_QString); } - QStringList _ret = self->entryList(nameFilters_QList, static_cast(filters)); + QList _ret = self->entryList(nameFilters_QList, static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -655,23 +655,23 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList3(const QDir* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QDir_entryList4(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int sort) { - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); nameFilters_QList.push_back(nameFilters_arr_i_QString); } - QStringList _ret = self->entryList(nameFilters_QList, static_cast(filters), static_cast(sort)); + QList _ret = self->entryList(nameFilters_QList, static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -682,73 +682,73 @@ struct miqt_array /* of struct miqt_string */ QDir_entryList4(const QDir* self, _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoListWithFilters(const QDir* self, int filters) { - QFileInfoList _ret = self->entryInfoList(static_cast(filters)); + QList _ret = self->entryInfoList(static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoList2(const QDir* self, int filters, int sort) { - QFileInfoList _ret = self->entryInfoList(static_cast(filters), static_cast(sort)); + QList _ret = self->entryInfoList(static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoList3(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters) { - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); nameFilters_QList.push_back(nameFilters_arr_i_QString); } - QFileInfoList _ret = self->entryInfoList(nameFilters_QList, static_cast(filters)); + QList _ret = self->entryInfoList(nameFilters_QList, static_cast(filters)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QFileInfo* */ QDir_entryInfoList4(const QDir* self, struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int sort) { - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { QString nameFilters_arr_i_QString = QString::fromUtf8(nameFilters_arr[i].data, nameFilters_arr[i].len); nameFilters_QList.push_back(nameFilters_arr_i_QString); } - QFileInfoList _ret = self->entryInfoList(nameFilters_QList, static_cast(filters), static_cast(sort)); + QList _ret = self->entryInfoList(nameFilters_QList, static_cast(filters), static_cast(sort)); // Convert QList<> from C++ memory to manually-managed C memory - QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QFileInfo** _arr = static_cast(malloc(sizeof(QFileInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QFileInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qdiriterator.cpp b/qt6/gen_qdiriterator.cpp index 4025be225f..463ddf4709 100644 --- a/qt6/gen_qdiriterator.cpp +++ b/qt6/gen_qdiriterator.cpp @@ -32,7 +32,7 @@ QDirIterator* QDirIterator_new3(struct miqt_string path, int filter) { QDirIterator* QDirIterator_new4(struct miqt_string path, struct miqt_array /* of struct miqt_string */ nameFilters) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { @@ -58,7 +58,7 @@ QDirIterator* QDirIterator_new7(struct miqt_string path, int filter, int flags) QDirIterator* QDirIterator_new8(struct miqt_string path, struct miqt_array /* of struct miqt_string */ nameFilters, int filters) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { @@ -70,7 +70,7 @@ QDirIterator* QDirIterator_new8(struct miqt_string path, struct miqt_array /* of QDirIterator* QDirIterator_new9(struct miqt_string path, struct miqt_array /* of struct miqt_string */ nameFilters, int filters, int flags) { QString path_QString = QString::fromUtf8(path.data, path.len); - QStringList nameFilters_QList; + QList nameFilters_QList; nameFilters_QList.reserve(nameFilters.len); struct miqt_string* nameFilters_arr = static_cast(nameFilters.data); for(size_t i = 0; i < nameFilters.len; ++i) { diff --git a/qt6/gen_qeasingcurve.cpp b/qt6/gen_qeasingcurve.cpp index 3251d40e33..f69478809e 100644 --- a/qt6/gen_qeasingcurve.cpp +++ b/qt6/gen_qeasingcurve.cpp @@ -78,12 +78,12 @@ void QEasingCurve_addTCBSegment(QEasingCurve* self, QPointF* nextPoint, double t struct miqt_array /* of QPointF* */ QEasingCurve_toCubicSpline(const QEasingCurve* self) { QList _ret = self->toCubicSpline(); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qevent.cpp b/qt6/gen_qevent.cpp index 0db74d6c1f..707f44e89c 100644 --- a/qt6/gen_qevent.cpp +++ b/qt6/gen_qevent.cpp @@ -494,12 +494,12 @@ QEventPoint* QPointerEvent_point(QPointerEvent* self, ptrdiff_t i) { struct miqt_array /* of QEventPoint* */ QPointerEvent_points(const QPointerEvent* self) { const QList& _ret = self->points(); // Convert QList<> from C++ memory to manually-managed C memory - QEventPoint** _arr = static_cast(malloc(sizeof(QEventPoint*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QEventPoint** _arr = static_cast(malloc(sizeof(QEventPoint*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QEventPoint(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3630,12 +3630,12 @@ void QInputMethodEvent_setCommitString(QInputMethodEvent* self, struct miqt_stri struct miqt_array /* of QInputMethodEvent__Attribute* */ QInputMethodEvent_attributes(const QInputMethodEvent* self) { const QList& _ret = self->attributes(); // Convert QList<> from C++ memory to manually-managed C memory - QInputMethodEvent__Attribute** _arr = static_cast(malloc(sizeof(QInputMethodEvent__Attribute*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QInputMethodEvent__Attribute** _arr = static_cast(malloc(sizeof(QInputMethodEvent__Attribute*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QInputMethodEvent::Attribute(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -5215,12 +5215,12 @@ uint8_t QTouchEvent_touchPointStates(const QTouchEvent* self) { struct miqt_array /* of QEventPoint* */ QTouchEvent_touchPoints(const QTouchEvent* self) { const QList& _ret = self->touchPoints(); // Convert QList<> from C++ memory to manually-managed C memory - QEventPoint** _arr = static_cast(malloc(sizeof(QEventPoint*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QEventPoint** _arr = static_cast(malloc(sizeof(QEventPoint*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QEventPoint(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qfactoryinterface.cpp b/qt6/gen_qfactoryinterface.cpp index 4a6a04a811..3b8a5d12ac 100644 --- a/qt6/gen_qfactoryinterface.cpp +++ b/qt6/gen_qfactoryinterface.cpp @@ -15,10 +15,10 @@ extern "C" { #endif struct miqt_array /* of struct miqt_string */ QFactoryInterface_keys(const QFactoryInterface* self) { - QStringList _ret = self->keys(); + QList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -29,7 +29,7 @@ struct miqt_array /* of struct miqt_string */ QFactoryInterface_keys(const QFac _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qfiledialog.cpp b/qt6/gen_qfiledialog.cpp index 84c260ea28..36e4a03db7 100644 --- a/qt6/gen_qfiledialog.cpp +++ b/qt6/gen_qfiledialog.cpp @@ -1093,10 +1093,10 @@ void QFileDialog_selectFile(QFileDialog* self, struct miqt_string filename) { } struct miqt_array /* of struct miqt_string */ QFileDialog_selectedFiles(const QFileDialog* self) { - QStringList _ret = self->selectedFiles(); + QList _ret = self->selectedFiles(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1107,7 +1107,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_selectedFiles(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1119,12 +1119,12 @@ void QFileDialog_selectUrl(QFileDialog* self, QUrl* url) { struct miqt_array /* of QUrl* */ QFileDialog_selectedUrls(const QFileDialog* self) { QList _ret = self->selectedUrls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1135,7 +1135,7 @@ void QFileDialog_setNameFilter(QFileDialog* self, struct miqt_string filter) { } void QFileDialog_setNameFilters(QFileDialog* self, struct miqt_array /* of struct miqt_string */ filters) { - QStringList filters_QList; + QList filters_QList; filters_QList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { @@ -1146,10 +1146,10 @@ void QFileDialog_setNameFilters(QFileDialog* self, struct miqt_array /* of struc } struct miqt_array /* of struct miqt_string */ QFileDialog_nameFilters(const QFileDialog* self) { - QStringList _ret = self->nameFilters(); + QList _ret = self->nameFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1160,7 +1160,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_nameFilters(const QFi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1193,7 +1193,7 @@ struct miqt_string QFileDialog_selectedNameFilter(const QFileDialog* self) { } void QFileDialog_setMimeTypeFilters(QFileDialog* self, struct miqt_array /* of struct miqt_string */ filters) { - QStringList filters_QList; + QList filters_QList; filters_QList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { @@ -1204,10 +1204,10 @@ void QFileDialog_setMimeTypeFilters(QFileDialog* self, struct miqt_array /* of s } struct miqt_array /* of struct miqt_string */ QFileDialog_mimeTypeFilters(const QFileDialog* self) { - QStringList _ret = self->mimeTypeFilters(); + QList _ret = self->mimeTypeFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1218,7 +1218,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_mimeTypeFilters(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1277,12 +1277,12 @@ void QFileDialog_setSidebarUrls(QFileDialog* self, struct miqt_array /* of QUrl* struct miqt_array /* of QUrl* */ QFileDialog_sidebarUrls(const QFileDialog* self) { QList _ret = self->sidebarUrls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1318,7 +1318,7 @@ struct miqt_string QFileDialog_defaultSuffix(const QFileDialog* self) { } void QFileDialog_setHistory(QFileDialog* self, struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { @@ -1329,10 +1329,10 @@ void QFileDialog_setHistory(QFileDialog* self, struct miqt_array /* of struct mi } struct miqt_array /* of struct miqt_string */ QFileDialog_history(const QFileDialog* self) { - QStringList _ret = self->history(); + QList _ret = self->history(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1343,7 +1343,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_history(const QFileDi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1381,7 +1381,7 @@ struct miqt_string QFileDialog_labelText(const QFileDialog* self, int label) { } void QFileDialog_setSupportedSchemes(QFileDialog* self, struct miqt_array /* of struct miqt_string */ schemes) { - QStringList schemes_QList; + QList schemes_QList; schemes_QList.reserve(schemes.len); struct miqt_string* schemes_arr = static_cast(schemes.data); for(size_t i = 0; i < schemes.len; ++i) { @@ -1392,10 +1392,10 @@ void QFileDialog_setSupportedSchemes(QFileDialog* self, struct miqt_array /* of } struct miqt_array /* of struct miqt_string */ QFileDialog_supportedSchemes(const QFileDialog* self) { - QStringList _ret = self->supportedSchemes(); + QList _ret = self->supportedSchemes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1406,7 +1406,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_supportedSchemes(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1460,7 +1460,7 @@ void QFileDialog_connect_fileSelected(QFileDialog* self, intptr_t slot) { } void QFileDialog_filesSelected(QFileDialog* self, struct miqt_array /* of struct miqt_string */ files) { - QStringList files_QList; + QList files_QList; files_QList.reserve(files.len); struct miqt_string* files_arr = static_cast(files.data); for(size_t i = 0; i < files.len; ++i) { @@ -1471,11 +1471,11 @@ void QFileDialog_filesSelected(QFileDialog* self, struct miqt_array /* of struct } void QFileDialog_connect_filesSelected(QFileDialog* self, intptr_t slot) { - QFileDialog::connect(self, static_cast(&QFileDialog::filesSelected), self, [=](const QStringList& files) { - const QStringList& files_ret = files; + QFileDialog::connect(self, static_cast&)>(&QFileDialog::filesSelected), self, [=](const QList& files) { + const QList& files_ret = files; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* files_arr = static_cast(malloc(sizeof(struct miqt_string) * files_ret.length())); - for (size_t i = 0, e = files_ret.length(); i < e; ++i) { + struct miqt_string* files_arr = static_cast(malloc(sizeof(struct miqt_string) * files_ret.size())); + for (size_t i = 0, e = files_ret.size(); i < e; ++i) { QString files_lv_ret = files_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray files_lv_b = files_lv_ret.toUtf8(); @@ -1486,7 +1486,7 @@ void QFileDialog_connect_filesSelected(QFileDialog* self, intptr_t slot) { files_arr[i] = files_lv_ms; } struct miqt_array files_out; - files_out.len = files_ret.length(); + files_out.len = files_ret.size(); files_out.data = static_cast(files_arr); struct miqt_array /* of struct miqt_string */ sigval1 = files_out; miqt_exec_callback_QFileDialog_filesSelected(slot, sigval1); @@ -1558,12 +1558,12 @@ void QFileDialog_connect_urlsSelected(QFileDialog* self, intptr_t slot) { QFileDialog::connect(self, static_cast&)>(&QFileDialog::urlsSelected), self, [=](const QList& urls) { const QList& urls_ret = urls; // Convert QList<> from C++ memory to manually-managed C memory - QUrl** urls_arr = static_cast(malloc(sizeof(QUrl*) * urls_ret.length())); - for (size_t i = 0, e = urls_ret.length(); i < e; ++i) { + QUrl** urls_arr = static_cast(malloc(sizeof(QUrl*) * urls_ret.size())); + for (size_t i = 0, e = urls_ret.size(); i < e; ++i) { urls_arr[i] = new QUrl(urls_ret[i]); } struct miqt_array urls_out; - urls_out.len = urls_ret.length(); + urls_out.len = urls_ret.size(); urls_out.data = static_cast(urls_arr); struct miqt_array /* of QUrl* */ sigval1 = urls_out; miqt_exec_callback_QFileDialog_urlsSelected(slot, sigval1); @@ -1661,10 +1661,10 @@ QUrl* QFileDialog_getExistingDirectoryUrl() { } struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames() { - QStringList _ret = QFileDialog::getOpenFileNames(); + QList _ret = QFileDialog::getOpenFileNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1675,7 +1675,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1683,12 +1683,12 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames() { struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls() { QList _ret = QFileDialog::getOpenFileUrls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1935,7 +1935,7 @@ QUrl* QFileDialog_getExistingDirectoryUrl4(QWidget* parent, struct miqt_string c QUrl* QFileDialog_getExistingDirectoryUrl5(QWidget* parent, struct miqt_string caption, QUrl* dir, int options, struct miqt_array /* of struct miqt_string */ supportedSchemes) { QString caption_QString = QString::fromUtf8(caption.data, caption.len); - QStringList supportedSchemes_QList; + QList supportedSchemes_QList; supportedSchemes_QList.reserve(supportedSchemes.len); struct miqt_string* supportedSchemes_arr = static_cast(supportedSchemes.data); for(size_t i = 0; i < supportedSchemes.len; ++i) { @@ -1946,10 +1946,10 @@ QUrl* QFileDialog_getExistingDirectoryUrl5(QWidget* parent, struct miqt_string c } struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNamesWithParent(QWidget* parent) { - QStringList _ret = QFileDialog::getOpenFileNames(parent); + QList _ret = QFileDialog::getOpenFileNames(parent); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1960,17 +1960,17 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNamesWithP _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames2(QWidget* parent, struct miqt_string caption) { QString caption_QString = QString::fromUtf8(caption.data, caption.len); - QStringList _ret = QFileDialog::getOpenFileNames(parent, caption_QString); + QList _ret = QFileDialog::getOpenFileNames(parent, caption_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1981,7 +1981,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames2(QWi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1989,10 +1989,10 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames2(QWi struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames3(QWidget* parent, struct miqt_string caption, struct miqt_string dir) { QString caption_QString = QString::fromUtf8(caption.data, caption.len); QString dir_QString = QString::fromUtf8(dir.data, dir.len); - QStringList _ret = QFileDialog::getOpenFileNames(parent, caption_QString, dir_QString); + QList _ret = QFileDialog::getOpenFileNames(parent, caption_QString, dir_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2003,7 +2003,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames3(QWi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2012,10 +2012,10 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames4(QWi QString caption_QString = QString::fromUtf8(caption.data, caption.len); QString dir_QString = QString::fromUtf8(dir.data, dir.len); QString filter_QString = QString::fromUtf8(filter.data, filter.len); - QStringList _ret = QFileDialog::getOpenFileNames(parent, caption_QString, dir_QString, filter_QString); + QList _ret = QFileDialog::getOpenFileNames(parent, caption_QString, dir_QString, filter_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2026,7 +2026,7 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames4(QWi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2034,12 +2034,12 @@ struct miqt_array /* of struct miqt_string */ QFileDialog_getOpenFileNames4(QWi struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrlsWithParent(QWidget* parent) { QList _ret = QFileDialog::getOpenFileUrls(parent); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2048,12 +2048,12 @@ struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls2(QWidget* parent, QString caption_QString = QString::fromUtf8(caption.data, caption.len); QList _ret = QFileDialog::getOpenFileUrls(parent, caption_QString); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2062,12 +2062,12 @@ struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls3(QWidget* parent, QString caption_QString = QString::fromUtf8(caption.data, caption.len); QList _ret = QFileDialog::getOpenFileUrls(parent, caption_QString, *dir); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2077,12 +2077,12 @@ struct miqt_array /* of QUrl* */ QFileDialog_getOpenFileUrls4(QWidget* parent, QString filter_QString = QString::fromUtf8(filter.data, filter.len); QList _ret = QFileDialog::getOpenFileUrls(parent, caption_QString, *dir, filter_QString); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qfileselector.cpp b/qt6/gen_qfileselector.cpp index 11ca18f8a2..40f7250734 100644 --- a/qt6/gen_qfileselector.cpp +++ b/qt6/gen_qfileselector.cpp @@ -213,10 +213,10 @@ QUrl* QFileSelector_selectWithFilePath(const QFileSelector* self, QUrl* filePath } struct miqt_array /* of struct miqt_string */ QFileSelector_extraSelectors(const QFileSelector* self) { - QStringList _ret = self->extraSelectors(); + QList _ret = self->extraSelectors(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -227,13 +227,13 @@ struct miqt_array /* of struct miqt_string */ QFileSelector_extraSelectors(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QFileSelector_setExtraSelectors(QFileSelector* self, struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; + QList list_QList; list_QList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -244,10 +244,10 @@ void QFileSelector_setExtraSelectors(QFileSelector* self, struct miqt_array /* o } struct miqt_array /* of struct miqt_string */ QFileSelector_allSelectors(const QFileSelector* self) { - QStringList _ret = self->allSelectors(); + QList _ret = self->allSelectors(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -258,7 +258,7 @@ struct miqt_array /* of struct miqt_string */ QFileSelector_allSelectors(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qfilesystemmodel.cpp b/qt6/gen_qfilesystemmodel.cpp index 19ade0db22..dffc003266 100644 --- a/qt6/gen_qfilesystemmodel.cpp +++ b/qt6/gen_qfilesystemmodel.cpp @@ -340,13 +340,13 @@ class MiqtVirtualQFileSystemModel final : public QFileSystemModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QFileSystemModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QFileSystemModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -362,19 +362,19 @@ class MiqtVirtualQFileSystemModel final : public QFileSystemModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QFileSystemModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QFileSystemModel_mimeData(this, handle__mimeData, sigval1); @@ -762,7 +762,7 @@ class MiqtVirtualQFileSystemModel final : public QFileSystemModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QFileSystemModel::match(start, role, value, hits, flags); } @@ -778,7 +778,7 @@ class MiqtVirtualQFileSystemModel final : public QFileSystemModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QFileSystemModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1159,10 +1159,10 @@ void QFileSystemModel_sort(QFileSystemModel* self, int column, int order) { } struct miqt_array /* of struct miqt_string */ QFileSystemModel_mimeTypes(const QFileSystemModel* self) { - QStringList _ret = self->mimeTypes(); + QList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1173,13 +1173,13 @@ struct miqt_array /* of struct miqt_string */ QFileSystemModel_mimeTypes(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QFileSystemModel_mimeData(const QFileSystemModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1282,7 +1282,7 @@ bool QFileSystemModel_nameFilterDisables(const QFileSystemModel* self) { } void QFileSystemModel_setNameFilters(QFileSystemModel* self, struct miqt_array /* of struct miqt_string */ filters) { - QStringList filters_QList; + QList filters_QList; filters_QList.reserve(filters.len); struct miqt_string* filters_arr = static_cast(filters.data); for(size_t i = 0; i < filters.len; ++i) { @@ -1293,10 +1293,10 @@ void QFileSystemModel_setNameFilters(QFileSystemModel* self, struct miqt_array / } struct miqt_array /* of struct miqt_string */ QFileSystemModel_nameFilters(const QFileSystemModel* self) { - QStringList _ret = self->nameFilters(); + QList _ret = self->nameFilters(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1307,7 +1307,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemModel_nameFilters(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1630,10 +1630,10 @@ bool QFileSystemModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QFileSystemModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QFileSystemModel::mimeTypes(); + QList _ret = static_cast(self)->QFileSystemModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1644,7 +1644,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemModel_virtualbase_mime _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1660,7 +1660,7 @@ bool QFileSystemModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QFileSystemModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1973,14 +1973,14 @@ bool QFileSystemModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QFileSystemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QFileSystemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QFileSystemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2144,7 +2144,7 @@ void QFileSystemModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const voi } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2337,13 +2337,13 @@ void QFileSystemModel_protectedbase_changePersistentIndexList(bool* _dynamic_cas } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2360,14 +2360,14 @@ struct miqt_array /* of QModelIndex* */ QFileSystemModel_protectedbase_persiste } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qfilesystemwatcher.cpp b/qt6/gen_qfilesystemwatcher.cpp index 7ac55d3f8c..70aa52e257 100644 --- a/qt6/gen_qfilesystemwatcher.cpp +++ b/qt6/gen_qfilesystemwatcher.cpp @@ -33,9 +33,9 @@ class MiqtVirtualQFileSystemWatcher final : public QFileSystemWatcher { public: MiqtVirtualQFileSystemWatcher(): QFileSystemWatcher() {} - MiqtVirtualQFileSystemWatcher(const QStringList& paths): QFileSystemWatcher(paths) {} + MiqtVirtualQFileSystemWatcher(const QList& paths): QFileSystemWatcher(paths) {} MiqtVirtualQFileSystemWatcher(QObject* parent): QFileSystemWatcher(parent) {} - MiqtVirtualQFileSystemWatcher(const QStringList& paths, QObject* parent): QFileSystemWatcher(paths, parent) {} + MiqtVirtualQFileSystemWatcher(const QList& paths, QObject* parent): QFileSystemWatcher(paths, parent) {} virtual ~MiqtVirtualQFileSystemWatcher() override = default; @@ -173,7 +173,7 @@ QFileSystemWatcher* QFileSystemWatcher_new() { } QFileSystemWatcher* QFileSystemWatcher_new2(struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { @@ -188,7 +188,7 @@ QFileSystemWatcher* QFileSystemWatcher_new3(QObject* parent) { } QFileSystemWatcher* QFileSystemWatcher_new4(struct miqt_array /* of struct miqt_string */ paths, QObject* parent) { - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { @@ -227,17 +227,17 @@ bool QFileSystemWatcher_addPath(QFileSystemWatcher* self, struct miqt_string fil } struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_addPaths(QFileSystemWatcher* self, struct miqt_array /* of struct miqt_string */ files) { - QStringList files_QList; + QList files_QList; files_QList.reserve(files.len); struct miqt_string* files_arr = static_cast(files.data); for(size_t i = 0; i < files.len; ++i) { QString files_arr_i_QString = QString::fromUtf8(files_arr[i].data, files_arr[i].len); files_QList.push_back(files_arr_i_QString); } - QStringList _ret = self->addPaths(files_QList); + QList _ret = self->addPaths(files_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -248,7 +248,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_addPaths(QFile _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -259,17 +259,17 @@ bool QFileSystemWatcher_removePath(QFileSystemWatcher* self, struct miqt_string } struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_removePaths(QFileSystemWatcher* self, struct miqt_array /* of struct miqt_string */ files) { - QStringList files_QList; + QList files_QList; files_QList.reserve(files.len); struct miqt_string* files_arr = static_cast(files.data); for(size_t i = 0; i < files.len; ++i) { QString files_arr_i_QString = QString::fromUtf8(files_arr[i].data, files_arr[i].len); files_QList.push_back(files_arr_i_QString); } - QStringList _ret = self->removePaths(files_QList); + QList _ret = self->removePaths(files_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -280,16 +280,16 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_removePaths(QF _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_files(const QFileSystemWatcher* self) { - QStringList _ret = self->files(); + QList _ret = self->files(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -300,16 +300,16 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_files(const QF _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_directories(const QFileSystemWatcher* self) { - QStringList _ret = self->directories(); + QList _ret = self->directories(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -320,7 +320,7 @@ struct miqt_array /* of struct miqt_string */ QFileSystemWatcher_directories(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qfont.cpp b/qt6/gen_qfont.cpp index d1d2f0ef40..8fac176bf1 100644 --- a/qt6/gen_qfont.cpp +++ b/qt6/gen_qfont.cpp @@ -26,7 +26,7 @@ QFont* QFont_new2(struct miqt_string family) { } QFont* QFont_new3(struct miqt_array /* of struct miqt_string */ families) { - QStringList families_QList; + QList families_QList; families_QList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { @@ -60,7 +60,7 @@ QFont* QFont_new8(struct miqt_string family, int pointSize, int weight, bool ita } QFont* QFont_new9(struct miqt_array /* of struct miqt_string */ families, int pointSize) { - QStringList families_QList; + QList families_QList; families_QList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { @@ -71,7 +71,7 @@ QFont* QFont_new9(struct miqt_array /* of struct miqt_string */ families, int p } QFont* QFont_new10(struct miqt_array /* of struct miqt_string */ families, int pointSize, int weight) { - QStringList families_QList; + QList families_QList; families_QList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { @@ -82,7 +82,7 @@ QFont* QFont_new10(struct miqt_array /* of struct miqt_string */ families, int } QFont* QFont_new11(struct miqt_array /* of struct miqt_string */ families, int pointSize, int weight, bool italic) { - QStringList families_QList; + QList families_QList; families_QList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { @@ -113,10 +113,10 @@ void QFont_setFamily(QFont* self, struct miqt_string family) { } struct miqt_array /* of struct miqt_string */ QFont_families(const QFont* self) { - QStringList _ret = self->families(); + QList _ret = self->families(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -127,13 +127,13 @@ struct miqt_array /* of struct miqt_string */ QFont_families(const QFont* self) _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QFont_setFamilies(QFont* self, struct miqt_array /* of struct miqt_string */ families) { - QStringList families_QList; + QList families_QList; families_QList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { @@ -394,10 +394,10 @@ struct miqt_string QFont_substitute(struct miqt_string param1) { struct miqt_array /* of struct miqt_string */ QFont_substitutes(struct miqt_string param1) { QString param1_QString = QString::fromUtf8(param1.data, param1.len); - QStringList _ret = QFont::substitutes(param1_QString); + QList _ret = QFont::substitutes(param1_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -408,16 +408,16 @@ struct miqt_array /* of struct miqt_string */ QFont_substitutes(struct miqt_str _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QFont_substitutions() { - QStringList _ret = QFont::substitutions(); + QList _ret = QFont::substitutions(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -428,7 +428,7 @@ struct miqt_array /* of struct miqt_string */ QFont_substitutions() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -441,7 +441,7 @@ void QFont_insertSubstitution(struct miqt_string param1, struct miqt_string para void QFont_insertSubstitutions(struct miqt_string param1, struct miqt_array /* of struct miqt_string */ param2) { QString param1_QString = QString::fromUtf8(param1.data, param1.len); - QStringList param2_QList; + QList param2_QList; param2_QList.reserve(param2.len); struct miqt_string* param2_arr = static_cast(param2.data); for(size_t i = 0; i < param2.len; ++i) { diff --git a/qt6/gen_qfontdatabase.cpp b/qt6/gen_qfontdatabase.cpp index a83bd3af55..a659df845f 100644 --- a/qt6/gen_qfontdatabase.cpp +++ b/qt6/gen_qfontdatabase.cpp @@ -24,12 +24,12 @@ QFontDatabase* QFontDatabase_new() { struct miqt_array /* of int */ QFontDatabase_standardSizes() { QList _ret = QFontDatabase::standardSizes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -37,13 +37,13 @@ struct miqt_array /* of int */ QFontDatabase_standardSizes() { struct miqt_array /* of int */ QFontDatabase_writingSystems() { QList _ret = QFontDatabase::writingSystems(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QFontDatabase::WritingSystem _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -52,22 +52,22 @@ struct miqt_array /* of int */ QFontDatabase_writingSystemsWithFamily(struct mi QString family_QString = QString::fromUtf8(family.data, family.len); QList _ret = QFontDatabase::writingSystems(family_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QFontDatabase::WritingSystem _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QFontDatabase_families() { - QStringList _ret = QFontDatabase::families(); + QList _ret = QFontDatabase::families(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -78,17 +78,17 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_families() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QFontDatabase_styles(struct miqt_string family) { QString family_QString = QString::fromUtf8(family.data, family.len); - QStringList _ret = QFontDatabase::styles(family_QString); + QList _ret = QFontDatabase::styles(family_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -99,7 +99,7 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_styles(struct miqt_ _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -108,12 +108,12 @@ struct miqt_array /* of int */ QFontDatabase_pointSizes(struct miqt_string fami QString family_QString = QString::fromUtf8(family.data, family.len); QList _ret = QFontDatabase::pointSizes(family_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -123,12 +123,12 @@ struct miqt_array /* of int */ QFontDatabase_smoothSizes(struct miqt_string fam QString style_QString = QString::fromUtf8(style.data, style.len); QList _ret = QFontDatabase::smoothSizes(family_QString, style_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -242,10 +242,10 @@ int QFontDatabase_addApplicationFontFromData(struct miqt_string fontData) { } struct miqt_array /* of struct miqt_string */ QFontDatabase_applicationFontFamilies(int id) { - QStringList _ret = QFontDatabase::applicationFontFamilies(static_cast(id)); + QList _ret = QFontDatabase::applicationFontFamilies(static_cast(id)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -256,7 +256,7 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_applicationFontFami _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -274,10 +274,10 @@ QFont* QFontDatabase_systemFont(int type) { } struct miqt_array /* of struct miqt_string */ QFontDatabase_familiesWithWritingSystem(int writingSystem) { - QStringList _ret = QFontDatabase::families(static_cast(writingSystem)); + QList _ret = QFontDatabase::families(static_cast(writingSystem)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -288,7 +288,7 @@ struct miqt_array /* of struct miqt_string */ QFontDatabase_familiesWithWriting _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -298,12 +298,12 @@ struct miqt_array /* of int */ QFontDatabase_pointSizes2(struct miqt_string fam QString style_QString = QString::fromUtf8(style.data, style.len); QList _ret = QFontDatabase::pointSizes(family_QString, style_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgenericpluginfactory.cpp b/qt6/gen_qgenericpluginfactory.cpp index beb05cec64..44f16a9bcc 100644 --- a/qt6/gen_qgenericpluginfactory.cpp +++ b/qt6/gen_qgenericpluginfactory.cpp @@ -16,10 +16,10 @@ extern "C" { #endif struct miqt_array /* of struct miqt_string */ QGenericPluginFactory_keys() { - QStringList _ret = QGenericPluginFactory::keys(); + QList _ret = QGenericPluginFactory::keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -30,7 +30,7 @@ struct miqt_array /* of struct miqt_string */ QGenericPluginFactory_keys() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgesture.cpp b/qt6/gen_qgesture.cpp index 6cbc8adc76..ac5a7c06bf 100644 --- a/qt6/gen_qgesture.cpp +++ b/qt6/gen_qgesture.cpp @@ -2294,7 +2294,7 @@ void QTapAndHoldGesture_delete(QTapAndHoldGesture* self) { class MiqtVirtualQGestureEvent final : public QGestureEvent { public: - MiqtVirtualQGestureEvent(const QList& gestures): QGestureEvent(gestures) {} + MiqtVirtualQGestureEvent(const QList& gestures): QGestureEvent(gestures) {} MiqtVirtualQGestureEvent(const QGestureEvent& param1): QGestureEvent(param1) {} virtual ~MiqtVirtualQGestureEvent() override = default; @@ -2334,7 +2334,7 @@ class MiqtVirtualQGestureEvent final : public QGestureEvent { }; QGestureEvent* QGestureEvent_new(struct miqt_array /* of QGesture* */ gestures) { - QList gestures_QList; + QList gestures_QList; gestures_QList.reserve(gestures.len); QGesture** gestures_arr = static_cast(gestures.data); for(size_t i = 0; i < gestures.len; ++i) { @@ -2352,14 +2352,14 @@ void QGestureEvent_virtbase(QGestureEvent* src, QEvent** outptr_QEvent) { } struct miqt_array /* of QGesture* */ QGestureEvent_gestures(const QGestureEvent* self) { - QList _ret = self->gestures(); + QList _ret = self->gestures(); // Convert QList<> from C++ memory to manually-managed C memory - QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2369,27 +2369,27 @@ QGesture* QGestureEvent_gesture(const QGestureEvent* self, int type) { } struct miqt_array /* of QGesture* */ QGestureEvent_activeGestures(const QGestureEvent* self) { - QList _ret = self->activeGestures(); + QList _ret = self->activeGestures(); // Convert QList<> from C++ memory to manually-managed C memory - QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGesture* */ QGestureEvent_canceledGestures(const QGestureEvent* self) { - QList _ret = self->canceledGestures(); + QList _ret = self->canceledGestures(); // Convert QList<> from C++ memory to manually-managed C memory - QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGesture** _arr = static_cast(malloc(sizeof(QGesture*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgesturerecognizer.cpp b/qt6/gen_qgesturerecognizer.cpp index 63fa86bde4..16aace3fc5 100644 --- a/qt6/gen_qgesturerecognizer.cpp +++ b/qt6/gen_qgesturerecognizer.cpp @@ -45,7 +45,7 @@ class MiqtVirtualQGestureRecognizer final : public QGestureRecognizer { // Subclass to allow providing a Go implementation virtual QGestureRecognizer::Result recognize(QGesture* state, QObject* watched, QEvent* event) override { if (handle__recognize == 0) { - return QGestureRecognizer::Result(); // Pure virtual, there is no base we can call + return (QGestureRecognizer::Result)(0); // Pure virtual, there is no base we can call } QGesture* sigval1 = state; diff --git a/qt6/gen_qglyphrun.cpp b/qt6/gen_qglyphrun.cpp index 357d82e5cb..e7ef4ef463 100644 --- a/qt6/gen_qglyphrun.cpp +++ b/qt6/gen_qglyphrun.cpp @@ -43,20 +43,20 @@ void QGlyphRun_setRawData(QGlyphRun* self, const unsigned int* glyphIndexArray, } struct miqt_array /* of unsigned int */ QGlyphRun_glyphIndexes(const QGlyphRun* self) { - QList _ret = self->glyphIndexes(); + QList _ret = self->glyphIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QGlyphRun_setGlyphIndexes(QGlyphRun* self, struct miqt_array /* of unsigned int */ glyphIndexes) { - QList glyphIndexes_QList; + QList glyphIndexes_QList; glyphIndexes_QList.reserve(glyphIndexes.len); unsigned int* glyphIndexes_arr = static_cast(glyphIndexes.data); for(size_t i = 0; i < glyphIndexes.len; ++i) { @@ -68,12 +68,12 @@ void QGlyphRun_setGlyphIndexes(QGlyphRun* self, struct miqt_array /* of unsigned struct miqt_array /* of QPointF* */ QGlyphRun_positions(const QGlyphRun* self) { QList _ret = self->positions(); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgraphicsitem.cpp b/qt6/gen_qgraphicsitem.cpp index 6e676704ef..21091ddbad 100644 --- a/qt6/gen_qgraphicsitem.cpp +++ b/qt6/gen_qgraphicsitem.cpp @@ -1165,14 +1165,14 @@ void QGraphicsItem_setParentItem(QGraphicsItem* self, QGraphicsItem* parent) { } struct miqt_array /* of QGraphicsItem* */ QGraphicsItem_childItems(const QGraphicsItem* self) { - QList _ret = self->childItems(); + QList _ret = self->childItems(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1520,20 +1520,20 @@ double QGraphicsItem_scale(const QGraphicsItem* self) { } struct miqt_array /* of QGraphicsTransform* */ QGraphicsItem_transformations(const QGraphicsItem* self) { - QList _ret = self->transformations(); + QList _ret = self->transformations(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsTransform** _arr = static_cast(malloc(sizeof(QGraphicsTransform*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsTransform** _arr = static_cast(malloc(sizeof(QGraphicsTransform*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QGraphicsItem_setTransformations(QGraphicsItem* self, struct miqt_array /* of QGraphicsTransform* */ transformations) { - QList transformations_QList; + QList transformations_QList; transformations_QList.reserve(transformations.len); QGraphicsTransform** transformations_arr = static_cast(transformations.data); for(size_t i = 0; i < transformations.len; ++i) { @@ -1608,14 +1608,14 @@ bool QGraphicsItem_collidesWithPath(const QGraphicsItem* self, QPainterPath* pat } struct miqt_array /* of QGraphicsItem* */ QGraphicsItem_collidingItems(const QGraphicsItem* self) { - QList _ret = self->collidingItems(); + QList _ret = self->collidingItems(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1867,14 +1867,14 @@ void QGraphicsItem_setTransform2(QGraphicsItem* self, QTransform* matrix, bool c } struct miqt_array /* of QGraphicsItem* */ QGraphicsItem_collidingItemsWithMode(const QGraphicsItem* self, int mode) { - QList _ret = self->collidingItems(static_cast(mode)); + QList _ret = self->collidingItems(static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgraphicsitemanimation.cpp b/qt6/gen_qgraphicsitemanimation.cpp index edb9a507a2..31d6db8008 100644 --- a/qt6/gen_qgraphicsitemanimation.cpp +++ b/qt6/gen_qgraphicsitemanimation.cpp @@ -259,10 +259,10 @@ QPointF* QGraphicsItemAnimation_posAt(const QGraphicsItemAnimation* self, double } struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_posList(const QGraphicsItemAnimation* self) { - QList> _ret = self->posList(); + QList> _ret = self->posList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -276,7 +276,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -295,10 +295,10 @@ double QGraphicsItemAnimation_rotationAt(const QGraphicsItemAnimation* self, dou } struct miqt_array /* of struct miqt_map tuple of double and double */ QGraphicsItemAnimation_rotationList(const QGraphicsItemAnimation* self) { - QList> _ret = self->rotationList(); + QList> _ret = self->rotationList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and double */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and double */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and double */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and double */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -312,7 +312,7 @@ struct miqt_array /* of struct miqt_map tuple of double and double */ QGraph _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -332,10 +332,10 @@ double QGraphicsItemAnimation_yTranslationAt(const QGraphicsItemAnimation* self, } struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_translationList(const QGraphicsItemAnimation* self) { - QList> _ret = self->translationList(); + QList> _ret = self->translationList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -349,7 +349,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -369,10 +369,10 @@ double QGraphicsItemAnimation_horizontalScaleAt(const QGraphicsItemAnimation* se } struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_scaleList(const QGraphicsItemAnimation* self) { - QList> _ret = self->scaleList(); + QList> _ret = self->scaleList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -386,7 +386,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -406,10 +406,10 @@ double QGraphicsItemAnimation_horizontalShearAt(const QGraphicsItemAnimation* se } struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGraphicsItemAnimation_shearList(const QGraphicsItemAnimation* self) { - QList> _ret = self->shearList(); + QList> _ret = self->shearList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QPointF* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QPointF* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -423,7 +423,7 @@ struct miqt_array /* of struct miqt_map tuple of double and QPointF* */ QGra _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgraphicsscene.cpp b/qt6/gen_qgraphicsscene.cpp index f3bdf8a05c..05c245256e 100644 --- a/qt6/gen_qgraphicsscene.cpp +++ b/qt6/gen_qgraphicsscene.cpp @@ -666,79 +666,79 @@ QRectF* QGraphicsScene_itemsBoundingRect(const QGraphicsScene* self) { } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items(const QGraphicsScene* self) { - QList _ret = self->items(); + QList _ret = self->items(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithPos(const QGraphicsScene* self, QPointF* pos) { - QList _ret = self->items(*pos); + QList _ret = self->items(*pos); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithRect(const QGraphicsScene* self, QRectF* rect) { - QList _ret = self->items(*rect); + QList _ret = self->items(*rect); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithPath(const QGraphicsScene* self, QPainterPath* path) { - QList _ret = self->items(*path); + QList _ret = self->items(*path); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items2(const QGraphicsScene* self, double x, double y, double w, double h, int mode, int order) { - QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode), static_cast(order)); + QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_collidingItems(const QGraphicsScene* self, QGraphicsItem* item) { - QList _ret = self->collidingItems(item); + QList _ret = self->collidingItems(item); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -752,14 +752,14 @@ QGraphicsItem* QGraphicsScene_itemAt2(const QGraphicsScene* self, double x, doub } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_selectedItems(const QGraphicsScene* self) { - QList _ret = self->selectedItems(); + QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -777,7 +777,7 @@ void QGraphicsScene_setSelectionAreaWithPath(QGraphicsScene* self, QPainterPath* } QGraphicsItemGroup* QGraphicsScene_createItemGroup(QGraphicsScene* self, struct miqt_array /* of QGraphicsItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QGraphicsItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -897,14 +897,14 @@ QVariant* QGraphicsScene_inputMethodQuery(const QGraphicsScene* self, int query) } struct miqt_array /* of QGraphicsView* */ QGraphicsScene_views(const QGraphicsScene* self) { - QList _ret = self->views(); + QList _ret = self->views(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsView** _arr = static_cast(malloc(sizeof(QGraphicsView*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsView** _arr = static_cast(malloc(sizeof(QGraphicsView*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1016,12 +1016,12 @@ void QGraphicsScene_connect_changed(QGraphicsScene* self, intptr_t slot) { QGraphicsScene::connect(self, static_cast&)>(&QGraphicsScene::changed), self, [=](const QList& region) { const QList& region_ret = region; // Convert QList<> from C++ memory to manually-managed C memory - QRectF** region_arr = static_cast(malloc(sizeof(QRectF*) * region_ret.length())); - for (size_t i = 0, e = region_ret.length(); i < e; ++i) { + QRectF** region_arr = static_cast(malloc(sizeof(QRectF*) * region_ret.size())); + for (size_t i = 0, e = region_ret.size(); i < e; ++i) { region_arr[i] = new QRectF(region_ret[i]); } struct miqt_array region_out; - region_out.len = region_ret.length(); + region_out.len = region_ret.size(); region_out.data = static_cast(region_arr); struct miqt_array /* of QRectF* */ sigval1 = region_out; miqt_exec_callback_QGraphicsScene_changed(slot, sigval1); @@ -1100,157 +1100,157 @@ void QGraphicsScene_render4(QGraphicsScene* self, QPainter* painter, QRectF* tar } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_itemsWithOrder(const QGraphicsScene* self, int order) { - QList _ret = self->items(static_cast(order)); + QList _ret = self->items(static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items3(const QGraphicsScene* self, QPointF* pos, int mode) { - QList _ret = self->items(*pos, static_cast(mode)); + QList _ret = self->items(*pos, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items4(const QGraphicsScene* self, QPointF* pos, int mode, int order) { - QList _ret = self->items(*pos, static_cast(mode), static_cast(order)); + QList _ret = self->items(*pos, static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items5(const QGraphicsScene* self, QPointF* pos, int mode, int order, QTransform* deviceTransform) { - QList _ret = self->items(*pos, static_cast(mode), static_cast(order), *deviceTransform); + QList _ret = self->items(*pos, static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items6(const QGraphicsScene* self, QRectF* rect, int mode) { - QList _ret = self->items(*rect, static_cast(mode)); + QList _ret = self->items(*rect, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items7(const QGraphicsScene* self, QRectF* rect, int mode, int order) { - QList _ret = self->items(*rect, static_cast(mode), static_cast(order)); + QList _ret = self->items(*rect, static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items8(const QGraphicsScene* self, QRectF* rect, int mode, int order, QTransform* deviceTransform) { - QList _ret = self->items(*rect, static_cast(mode), static_cast(order), *deviceTransform); + QList _ret = self->items(*rect, static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items12(const QGraphicsScene* self, QPainterPath* path, int mode) { - QList _ret = self->items(*path, static_cast(mode)); + QList _ret = self->items(*path, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items13(const QGraphicsScene* self, QPainterPath* path, int mode, int order) { - QList _ret = self->items(*path, static_cast(mode), static_cast(order)); + QList _ret = self->items(*path, static_cast(mode), static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items14(const QGraphicsScene* self, QPainterPath* path, int mode, int order, QTransform* deviceTransform) { - QList _ret = self->items(*path, static_cast(mode), static_cast(order), *deviceTransform); + QList _ret = self->items(*path, static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_items15(const QGraphicsScene* self, double x, double y, double w, double h, int mode, int order, QTransform* deviceTransform) { - QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode), static_cast(order), *deviceTransform); + QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode), static_cast(order), *deviceTransform); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsScene_collidingItems2(const QGraphicsScene* self, QGraphicsItem* item, int mode) { - QList _ret = self->collidingItems(item, static_cast(mode)); + QList _ret = self->collidingItems(item, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgraphicsview.cpp b/qt6/gen_qgraphicsview.cpp index dbaa0e6274..9cc1733996 100644 --- a/qt6/gen_qgraphicsview.cpp +++ b/qt6/gen_qgraphicsview.cpp @@ -1301,79 +1301,79 @@ void QGraphicsView_render(QGraphicsView* self, QPainter* painter) { } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items(const QGraphicsView* self) { - QList _ret = self->items(); + QList _ret = self->items(); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithPos(const QGraphicsView* self, QPoint* pos) { - QList _ret = self->items(*pos); + QList _ret = self->items(*pos); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items2(const QGraphicsView* self, int x, int y) { - QList _ret = self->items(static_cast(x), static_cast(y)); + QList _ret = self->items(static_cast(x), static_cast(y)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithRect(const QGraphicsView* self, QRect* rect) { - QList _ret = self->items(*rect); + QList _ret = self->items(*rect); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items3(const QGraphicsView* self, int x, int y, int w, int h) { - QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h)); + QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_itemsWithPath(const QGraphicsView* self, QPainterPath* path) { - QList _ret = self->items(*path); + QList _ret = self->items(*path); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1544,40 +1544,40 @@ void QGraphicsView_render4(QGraphicsView* self, QPainter* painter, QRectF* targe } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items4(const QGraphicsView* self, QRect* rect, int mode) { - QList _ret = self->items(*rect, static_cast(mode)); + QList _ret = self->items(*rect, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items5(const QGraphicsView* self, int x, int y, int w, int h, int mode) { - QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode)); + QList _ret = self->items(static_cast(x), static_cast(y), static_cast(w), static_cast(h), static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QGraphicsItem* */ QGraphicsView_items7(const QGraphicsView* self, QPainterPath* path, int mode) { - QList _ret = self->items(*path, static_cast(mode)); + QList _ret = self->items(*path, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGraphicsItem** _arr = static_cast(malloc(sizeof(QGraphicsItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qgraphicswidget.cpp b/qt6/gen_qgraphicswidget.cpp index 21eedee920..f0639acfd1 100644 --- a/qt6/gen_qgraphicswidget.cpp +++ b/qt6/gen_qgraphicswidget.cpp @@ -1479,7 +1479,7 @@ void QGraphicsWidget_addAction(QGraphicsWidget* self, QAction* action) { } void QGraphicsWidget_addActions(QGraphicsWidget* self, struct miqt_array /* of QAction* */ actions) { - QList actions_QList; + QList actions_QList; actions_QList.reserve(actions.len); QAction** actions_arr = static_cast(actions.data); for(size_t i = 0; i < actions.len; ++i) { @@ -1489,7 +1489,7 @@ void QGraphicsWidget_addActions(QGraphicsWidget* self, struct miqt_array /* of Q } void QGraphicsWidget_insertActions(QGraphicsWidget* self, QAction* before, struct miqt_array /* of QAction* */ actions) { - QList actions_QList; + QList actions_QList; actions_QList.reserve(actions.len); QAction** actions_arr = static_cast(actions.data); for(size_t i = 0; i < actions.len; ++i) { @@ -1507,14 +1507,14 @@ void QGraphicsWidget_removeAction(QGraphicsWidget* self, QAction* action) { } struct miqt_array /* of QAction* */ QGraphicsWidget_actions(const QGraphicsWidget* self) { - QList _ret = self->actions(); + QList _ret = self->actions(); // Convert QList<> from C++ memory to manually-managed C memory - QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qguiapplication.cpp b/qt6/gen_qguiapplication.cpp index 14aae10f71..fb5bb1aa09 100644 --- a/qt6/gen_qguiapplication.cpp +++ b/qt6/gen_qguiapplication.cpp @@ -273,27 +273,27 @@ struct miqt_string QGuiApplication_desktopFileName() { } struct miqt_array /* of QWindow* */ QGuiApplication_allWindows() { - QWindowList _ret = QGuiApplication::allWindows(); + QList _ret = QGuiApplication::allWindows(); // Convert QList<> from C++ memory to manually-managed C memory - QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QWindow* */ QGuiApplication_topLevelWindows() { - QWindowList _ret = QGuiApplication::topLevelWindows(); + QList _ret = QGuiApplication::topLevelWindows(); // Convert QList<> from C++ memory to manually-managed C memory - QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWindow** _arr = static_cast(malloc(sizeof(QWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -338,14 +338,14 @@ QScreen* QGuiApplication_primaryScreen() { } struct miqt_array /* of QScreen* */ QGuiApplication_screens() { - QList _ret = QGuiApplication::screens(); + QList _ret = QGuiApplication::screens(); // Convert QList<> from C++ memory to manually-managed C memory - QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qheaderview.cpp b/qt6/gen_qheaderview.cpp index 4bbf47ff70..012c2d529f 100644 --- a/qt6/gen_qheaderview.cpp +++ b/qt6/gen_qheaderview.cpp @@ -512,12 +512,12 @@ class MiqtVirtualQHeaderView final : public QHeaderView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QHeaderView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -1058,13 +1058,13 @@ class MiqtVirtualQHeaderView final : public QHeaderView { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QHeaderView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QHeaderView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -3033,14 +3033,14 @@ bool QHeaderView_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QHeaderView_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QHeaderView::selectedIndexes(); + QList _ret = static_cast(self)->QHeaderView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qicon.cpp b/qt6/gen_qicon.cpp index 0366ae8d9b..46b45fa253 100644 --- a/qt6/gen_qicon.cpp +++ b/qt6/gen_qicon.cpp @@ -130,12 +130,12 @@ void QIcon_addFile(QIcon* self, struct miqt_string fileName) { struct miqt_array /* of QSize* */ QIcon_availableSizes(const QIcon* self) { QList _ret = self->availableSizes(); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -164,10 +164,10 @@ bool QIcon_hasThemeIcon(struct miqt_string name) { } struct miqt_array /* of struct miqt_string */ QIcon_themeSearchPaths() { - QStringList _ret = QIcon::themeSearchPaths(); + QList _ret = QIcon::themeSearchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -178,13 +178,13 @@ struct miqt_array /* of struct miqt_string */ QIcon_themeSearchPaths() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QIcon_setThemeSearchPaths(struct miqt_array /* of struct miqt_string */ searchpath) { - QStringList searchpath_QList; + QList searchpath_QList; searchpath_QList.reserve(searchpath.len); struct miqt_string* searchpath_arr = static_cast(searchpath.data); for(size_t i = 0; i < searchpath.len; ++i) { @@ -195,10 +195,10 @@ void QIcon_setThemeSearchPaths(struct miqt_array /* of struct miqt_string */ se } struct miqt_array /* of struct miqt_string */ QIcon_fallbackSearchPaths() { - QStringList _ret = QIcon::fallbackSearchPaths(); + QList _ret = QIcon::fallbackSearchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -209,13 +209,13 @@ struct miqt_array /* of struct miqt_string */ QIcon_fallbackSearchPaths() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QIcon_setFallbackSearchPaths(struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { @@ -363,12 +363,12 @@ void QIcon_addFile4(QIcon* self, struct miqt_string fileName, QSize* size, int m struct miqt_array /* of QSize* */ QIcon_availableSizesWithMode(const QIcon* self, int mode) { QList _ret = self->availableSizes(static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -376,12 +376,12 @@ struct miqt_array /* of QSize* */ QIcon_availableSizesWithMode(const QIcon* sel struct miqt_array /* of QSize* */ QIcon_availableSizes2(const QIcon* self, int mode, int state) { QList _ret = self->availableSizes(static_cast(mode), static_cast(state)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qiconengine.cpp b/qt6/gen_qiconengine.cpp index e6f8742922..d07a13f552 100644 --- a/qt6/gen_qiconengine.cpp +++ b/qt6/gen_qiconengine.cpp @@ -376,12 +376,12 @@ bool QIconEngine_write(const QIconEngine* self, QDataStream* out) { struct miqt_array /* of QSize* */ QIconEngine_availableSizes(QIconEngine* self, int mode, int state) { QList _ret = self->availableSizes(static_cast(mode), static_cast(state)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -548,12 +548,12 @@ bool QIconEngine_override_virtual_availableSizes(void* self, intptr_t slot) { struct miqt_array /* of QSize* */ QIconEngine_virtualbase_availableSizes(void* self, int mode, int state) { QList _ret = static_cast(self)->QIconEngine::availableSizes(static_cast(mode), static_cast(state)); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qidentityproxymodel.cpp b/qt6/gen_qidentityproxymodel.cpp index 464e4d826b..cb03680c8c 100644 --- a/qt6/gen_qidentityproxymodel.cpp +++ b/qt6/gen_qidentityproxymodel.cpp @@ -301,7 +301,7 @@ class MiqtVirtualQIdentityProxyModel final : public QIdentityProxyModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QIdentityProxyModel::match(start, role, value, hits, flags); } @@ -317,7 +317,7 @@ class MiqtVirtualQIdentityProxyModel final : public QIdentityProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QIdentityProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -774,19 +774,19 @@ class MiqtVirtualQIdentityProxyModel final : public QIdentityProxyModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QIdentityProxyModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QIdentityProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -822,13 +822,13 @@ class MiqtVirtualQIdentityProxyModel final : public QIdentityProxyModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QIdentityProxyModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QIdentityProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1155,14 +1155,14 @@ QItemSelection* QIdentityProxyModel_mapSelectionToSource(const QIdentityProxyMod } struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_match(const QIdentityProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1382,14 +1382,14 @@ bool QIdentityProxyModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QIdentityProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QIdentityProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1734,7 +1734,7 @@ bool QIdentityProxyModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QIdentityProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1768,10 +1768,10 @@ bool QIdentityProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QIdentityProxyModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QIdentityProxyModel::mimeTypes(); + QList _ret = static_cast(self)->QIdentityProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1782,7 +1782,7 @@ struct miqt_array /* of struct miqt_string */ QIdentityProxyModel_virtualbase_m _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2006,7 +2006,7 @@ void QIdentityProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2199,13 +2199,13 @@ void QIdentityProxyModel_protectedbase_changePersistentIndexList(bool* _dynamic_ } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2222,14 +2222,14 @@ struct miqt_array /* of QModelIndex* */ QIdentityProxyModel_protectedbase_persi } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qimage.cpp b/qt6/gen_qimage.cpp index 87952c9212..3eb0c74786 100644 --- a/qt6/gen_qimage.cpp +++ b/qt6/gen_qimage.cpp @@ -259,7 +259,7 @@ QImage* QImage_convertToFormat(const QImage* self, int f) { } QImage* QImage_convertToFormat2(const QImage* self, int f, struct miqt_array /* of unsigned int */ colorTable) { - QList colorTable_QList; + QList colorTable_QList; colorTable_QList.reserve(colorTable.len); unsigned int* colorTable_arr = static_cast(colorTable.data); for(size_t i = 0; i < colorTable.len; ++i) { @@ -420,20 +420,20 @@ void QImage_setPixelColor2(QImage* self, QPoint* pt, QColor* c) { } struct miqt_array /* of unsigned int */ QImage_colorTable(const QImage* self) { - QList _ret = self->colorTable(); + QList _ret = self->colorTable(); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QImage_setColorTable(QImage* self, struct miqt_array /* of unsigned int */ colors) { - QList colors_QList; + QList colors_QList; colors_QList.reserve(colors.len); unsigned int* colors_arr = static_cast(colors.data); for(size_t i = 0; i < colors.len; ++i) { @@ -633,10 +633,10 @@ void QImage_setOffset(QImage* self, QPoint* offset) { } struct miqt_array /* of struct miqt_string */ QImage_textKeys(const QImage* self) { - QStringList _ret = self->textKeys(); + QList _ret = self->textKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -647,7 +647,7 @@ struct miqt_array /* of struct miqt_string */ QImage_textKeys(const QImage* sel _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -691,7 +691,7 @@ QImage* QImage_convertToFormat3(const QImage* self, int f, int flags) { } QImage* QImage_convertToFormat4(const QImage* self, int f, struct miqt_array /* of unsigned int */ colorTable, int flags) { - QList colorTable_QList; + QList colorTable_QList; colorTable_QList.reserve(colorTable.len); unsigned int* colorTable_arr = static_cast(colorTable.data); for(size_t i = 0; i < colorTable.len; ++i) { diff --git a/qt6/gen_qimageiohandler.cpp b/qt6/gen_qimageiohandler.cpp index 8e83c19fc6..28bdde759e 100644 --- a/qt6/gen_qimageiohandler.cpp +++ b/qt6/gen_qimageiohandler.cpp @@ -1,6 +1,4 @@ #include -#include -#include #include #include #include @@ -13,7 +11,6 @@ #include #include #include -#include #include #include #include "gen_qimageiohandler.h" @@ -35,15 +32,6 @@ int miqt_exec_callback_QImageIOHandler_imageCount(const QImageIOHandler*, intptr int miqt_exec_callback_QImageIOHandler_nextImageDelay(const QImageIOHandler*, intptr_t); int miqt_exec_callback_QImageIOHandler_currentImageNumber(const QImageIOHandler*, intptr_t); QRect* miqt_exec_callback_QImageIOHandler_currentImageRect(const QImageIOHandler*, intptr_t); -int miqt_exec_callback_QImageIOPlugin_capabilities(const QImageIOPlugin*, intptr_t, QIODevice*, struct miqt_string); -QImageIOHandler* miqt_exec_callback_QImageIOPlugin_create(const QImageIOPlugin*, intptr_t, QIODevice*, struct miqt_string); -bool miqt_exec_callback_QImageIOPlugin_event(QImageIOPlugin*, intptr_t, QEvent*); -bool miqt_exec_callback_QImageIOPlugin_eventFilter(QImageIOPlugin*, intptr_t, QObject*, QEvent*); -void miqt_exec_callback_QImageIOPlugin_timerEvent(QImageIOPlugin*, intptr_t, QTimerEvent*); -void miqt_exec_callback_QImageIOPlugin_childEvent(QImageIOPlugin*, intptr_t, QChildEvent*); -void miqt_exec_callback_QImageIOPlugin_customEvent(QImageIOPlugin*, intptr_t, QEvent*); -void miqt_exec_callback_QImageIOPlugin_connectNotify(QImageIOPlugin*, intptr_t, QMetaMethod*); -void miqt_exec_callback_QImageIOPlugin_disconnectNotify(QImageIOPlugin*, intptr_t, QMetaMethod*); #ifdef __cplusplus } /* extern C */ #endif @@ -528,191 +516,6 @@ void QImageIOHandler_delete(QImageIOHandler* self) { delete self; } -class MiqtVirtualQImageIOPlugin final : public QImageIOPlugin { -public: - - MiqtVirtualQImageIOPlugin(): QImageIOPlugin() {} - MiqtVirtualQImageIOPlugin(QObject* parent): QImageIOPlugin(parent) {} - - virtual ~MiqtVirtualQImageIOPlugin() override = default; - - // cgo.Handle value for overwritten implementation - intptr_t handle__capabilities = 0; - - // Subclass to allow providing a Go implementation - virtual QImageIOPlugin::Capabilities capabilities(QIODevice* device, const QByteArray& format) const override { - if (handle__capabilities == 0) { - return QImageIOPlugin::Capabilities(); // Pure virtual, there is no base we can call - } - - QIODevice* sigval1 = device; - const QByteArray format_qb = format; - struct miqt_string format_ms; - format_ms.len = format_qb.length(); - format_ms.data = static_cast(malloc(format_ms.len)); - memcpy(format_ms.data, format_qb.data(), format_ms.len); - struct miqt_string sigval2 = format_ms; - int callback_return_value = miqt_exec_callback_QImageIOPlugin_capabilities(this, handle__capabilities, sigval1, sigval2); - return static_cast(callback_return_value); - } - - // cgo.Handle value for overwritten implementation - intptr_t handle__create = 0; - - // Subclass to allow providing a Go implementation - virtual QImageIOHandler* create(QIODevice* device, const QByteArray& format) const override { - if (handle__create == 0) { - return nullptr; // Pure virtual, there is no base we can call - } - - QIODevice* sigval1 = device; - const QByteArray format_qb = format; - struct miqt_string format_ms; - format_ms.len = format_qb.length(); - format_ms.data = static_cast(malloc(format_ms.len)); - memcpy(format_ms.data, format_qb.data(), format_ms.len); - struct miqt_string sigval2 = format_ms; - QImageIOHandler* callback_return_value = miqt_exec_callback_QImageIOPlugin_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 QImageIOPlugin::event(event); - } - - QEvent* sigval1 = event; - bool callback_return_value = miqt_exec_callback_QImageIOPlugin_event(this, handle__event, sigval1); - return callback_return_value; - } - - friend bool QImageIOPlugin_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 QImageIOPlugin::eventFilter(watched, event); - } - - QObject* sigval1 = watched; - QEvent* sigval2 = event; - bool callback_return_value = miqt_exec_callback_QImageIOPlugin_eventFilter(this, handle__eventFilter, sigval1, sigval2); - return callback_return_value; - } - - friend bool QImageIOPlugin_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) { - QImageIOPlugin::timerEvent(event); - return; - } - - QTimerEvent* sigval1 = event; - miqt_exec_callback_QImageIOPlugin_timerEvent(this, handle__timerEvent, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::childEvent(event); - return; - } - - QChildEvent* sigval1 = event; - miqt_exec_callback_QImageIOPlugin_childEvent(this, handle__childEvent, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::customEvent(event); - return; - } - - QEvent* sigval1 = event; - miqt_exec_callback_QImageIOPlugin_customEvent(this, handle__customEvent, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::connectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QImageIOPlugin_connectNotify(this, handle__connectNotify, sigval1); - - } - - friend void QImageIOPlugin_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) { - QImageIOPlugin::disconnectNotify(signal); - return; - } - - const QMetaMethod& signal_ret = signal; - // Cast returned reference into pointer - QMetaMethod* sigval1 = const_cast(&signal_ret); - miqt_exec_callback_QImageIOPlugin_disconnectNotify(this, handle__disconnectNotify, sigval1); - - } - - friend void QImageIOPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - - // Wrappers to allow calling protected methods: - friend QObject* QImageIOPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); - friend int QImageIOPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); - friend int QImageIOPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); - friend bool QImageIOPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); -}; - -QImageIOPlugin* QImageIOPlugin_new() { - return new (std::nothrow) MiqtVirtualQImageIOPlugin(); -} - -QImageIOPlugin* QImageIOPlugin_new2(QObject* parent) { - return new (std::nothrow) MiqtVirtualQImageIOPlugin(parent); -} - void QImageIOPlugin_virtbase(QImageIOPlugin* src, QObject** outptr_QObject) { *outptr_QObject = static_cast(src); } @@ -769,168 +572,6 @@ struct miqt_string QImageIOPlugin_tr3(const char* s, const char* c, int n) { return _ms; } -bool QImageIOPlugin_override_virtual_capabilities(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__capabilities = slot; - return true; -} - -bool QImageIOPlugin_override_virtual_create(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__create = slot; - return true; -} - -bool QImageIOPlugin_override_virtual_event(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__event = slot; - return true; -} - -bool QImageIOPlugin_virtualbase_event(void* self, QEvent* event) { - return static_cast(self)->QImageIOPlugin::event(event); -} - -bool QImageIOPlugin_override_virtual_eventFilter(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__eventFilter = slot; - return true; -} - -bool QImageIOPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) { - return static_cast(self)->QImageIOPlugin::eventFilter(watched, event); -} - -bool QImageIOPlugin_override_virtual_timerEvent(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__timerEvent = slot; - return true; -} - -void QImageIOPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event) { - static_cast(self)->QImageIOPlugin::timerEvent(event); -} - -bool QImageIOPlugin_override_virtual_childEvent(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__childEvent = slot; - return true; -} - -void QImageIOPlugin_virtualbase_childEvent(void* self, QChildEvent* event) { - static_cast(self)->QImageIOPlugin::childEvent(event); -} - -bool QImageIOPlugin_override_virtual_customEvent(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__customEvent = slot; - return true; -} - -void QImageIOPlugin_virtualbase_customEvent(void* self, QEvent* event) { - static_cast(self)->QImageIOPlugin::customEvent(event); -} - -bool QImageIOPlugin_override_virtual_connectNotify(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__connectNotify = slot; - return true; -} - -void QImageIOPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QImageIOPlugin::connectNotify(*signal); -} - -bool QImageIOPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - return false; - } - - self_cast->handle__disconnectNotify = slot; - return true; -} - -void QImageIOPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) { - static_cast(self)->QImageIOPlugin::disconnectNotify(*signal); -} - -QObject* QImageIOPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return nullptr; - } - - *_dynamic_cast_ok = true; - return self_cast->sender(); -} - -int QImageIOPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->senderSignalIndex(); -} - -int QImageIOPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return 0; - } - - *_dynamic_cast_ok = true; - return self_cast->receivers(signal); -} - -bool QImageIOPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal) { - MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast( (QImageIOPlugin*)(self) ); - if (self_cast == nullptr) { - *_dynamic_cast_ok = false; - return false; - } - - *_dynamic_cast_ok = true; - return self_cast->isSignalConnected(*signal); -} - void QImageIOPlugin_delete(QImageIOPlugin* self) { delete self; } diff --git a/qt6/gen_qimageiohandler.go b/qt6/gen_qimageiohandler.go index 4c4176a23a..bd80115120 100644 --- a/qt6/gen_qimageiohandler.go +++ b/qt6/gen_qimageiohandler.go @@ -579,18 +579,6 @@ func UnsafeNewQImageIOPlugin(h unsafe.Pointer) *QImageIOPlugin { return newQImageIOPlugin((*C.QImageIOPlugin)(h)) } -// NewQImageIOPlugin constructs a new QImageIOPlugin object. -func NewQImageIOPlugin() *QImageIOPlugin { - - return newQImageIOPlugin(C.QImageIOPlugin_new()) -} - -// NewQImageIOPlugin2 constructs a new QImageIOPlugin object. -func NewQImageIOPlugin2(parent *QObject) *QImageIOPlugin { - - return newQImageIOPlugin(C.QImageIOPlugin_new2(parent.cPointer())) -} - func (this *QImageIOPlugin) MetaObject() *QMetaObject { return newQMetaObject(C.QImageIOPlugin_metaObject(this.h)) } @@ -654,306 +642,6 @@ func QImageIOPlugin_Tr3(s string, c string, n int) string { return _ret } -// Sender can only be called from a QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) Sender() *QObject { - - var _dynamic_cast_ok C.bool = false - _method_ret := newQObject(C.QImageIOPlugin_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 QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) SenderSignalIndex() int { - - var _dynamic_cast_ok C.bool = false - _method_ret := (int)(C.QImageIOPlugin_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 QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) 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.QImageIOPlugin_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 QImageIOPlugin that was directly constructed. -func (this *QImageIOPlugin) IsSignalConnected(signal *QMetaMethod) bool { - - var _dynamic_cast_ok C.bool = false - _method_ret := (bool)(C.QImageIOPlugin_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 *QImageIOPlugin) OnCapabilities(slot func(device *QIODevice, format []byte) QImageIOPlugin__Capability) { - ok := C.QImageIOPlugin_override_virtual_capabilities(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_QImageIOPlugin_capabilities -func miqt_exec_callback_QImageIOPlugin_capabilities(self *C.QImageIOPlugin, cb C.intptr_t, device *C.QIODevice, format C.struct_miqt_string) C.int { - gofunc, ok := cgo.Handle(cb).Value().(func(device *QIODevice, format []byte) QImageIOPlugin__Capability) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQIODevice(device) - - var format_bytearray C.struct_miqt_string = format - format_ret := C.GoBytes(unsafe.Pointer(format_bytearray.data), C.int(int64(format_bytearray.len))) - C.free(unsafe.Pointer(format_bytearray.data)) - slotval2 := format_ret - - virtualReturn := gofunc(slotval1, slotval2) - - return (C.int)(virtualReturn) - -} -func (this *QImageIOPlugin) OnCreate(slot func(device *QIODevice, format []byte) *QImageIOHandler) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_create -func miqt_exec_callback_QImageIOPlugin_create(self *C.QImageIOPlugin, cb C.intptr_t, device *C.QIODevice, format C.struct_miqt_string) *C.QImageIOHandler { - gofunc, ok := cgo.Handle(cb).Value().(func(device *QIODevice, format []byte) *QImageIOHandler) - if !ok { - panic("miqt: callback of non-callback type (heap corruption?)") - } - - // Convert all CABI parameters to Go parameters - slotval1 := newQIODevice(device) - - var format_bytearray C.struct_miqt_string = format - format_ret := C.GoBytes(unsafe.Pointer(format_bytearray.data), C.int(int64(format_bytearray.len))) - C.free(unsafe.Pointer(format_bytearray.data)) - slotval2 := format_ret - - virtualReturn := gofunc(slotval1, slotval2) - - return virtualReturn.cPointer() - -} - -func (this *QImageIOPlugin) callVirtualBase_Event(event *QEvent) bool { - - return (bool)(C.QImageIOPlugin_virtualbase_event(unsafe.Pointer(this.h), event.cPointer())) - -} -func (this *QImageIOPlugin) OnEvent(slot func(super func(event *QEvent) bool, event *QEvent) bool) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_event -func miqt_exec_callback_QImageIOPlugin_event(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_Event, slotval1) - - return (C.bool)(virtualReturn) - -} - -func (this *QImageIOPlugin) callVirtualBase_EventFilter(watched *QObject, event *QEvent) bool { - - return (bool)(C.QImageIOPlugin_virtualbase_eventFilter(unsafe.Pointer(this.h), watched.cPointer(), event.cPointer())) - -} -func (this *QImageIOPlugin) OnEventFilter(slot func(super func(watched *QObject, event *QEvent) bool, watched *QObject, event *QEvent) bool) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_eventFilter -func miqt_exec_callback_QImageIOPlugin_eventFilter(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_EventFilter, slotval1, slotval2) - - return (C.bool)(virtualReturn) - -} - -func (this *QImageIOPlugin) callVirtualBase_TimerEvent(event *QTimerEvent) { - - C.QImageIOPlugin_virtualbase_timerEvent(unsafe.Pointer(this.h), event.cPointer()) - -} -func (this *QImageIOPlugin) OnTimerEvent(slot func(super func(event *QTimerEvent), event *QTimerEvent)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_timerEvent -func miqt_exec_callback_QImageIOPlugin_timerEvent(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_TimerEvent, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_ChildEvent(event *QChildEvent) { - - C.QImageIOPlugin_virtualbase_childEvent(unsafe.Pointer(this.h), event.cPointer()) - -} -func (this *QImageIOPlugin) OnChildEvent(slot func(super func(event *QChildEvent), event *QChildEvent)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_childEvent -func miqt_exec_callback_QImageIOPlugin_childEvent(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_ChildEvent, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_CustomEvent(event *QEvent) { - - C.QImageIOPlugin_virtualbase_customEvent(unsafe.Pointer(this.h), event.cPointer()) - -} -func (this *QImageIOPlugin) OnCustomEvent(slot func(super func(event *QEvent), event *QEvent)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_customEvent -func miqt_exec_callback_QImageIOPlugin_customEvent(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_CustomEvent, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_ConnectNotify(signal *QMetaMethod) { - - C.QImageIOPlugin_virtualbase_connectNotify(unsafe.Pointer(this.h), signal.cPointer()) - -} -func (this *QImageIOPlugin) OnConnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_connectNotify -func miqt_exec_callback_QImageIOPlugin_connectNotify(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_ConnectNotify, slotval1) - -} - -func (this *QImageIOPlugin) callVirtualBase_DisconnectNotify(signal *QMetaMethod) { - - C.QImageIOPlugin_virtualbase_disconnectNotify(unsafe.Pointer(this.h), signal.cPointer()) - -} -func (this *QImageIOPlugin) OnDisconnectNotify(slot func(super func(signal *QMetaMethod), signal *QMetaMethod)) { - ok := C.QImageIOPlugin_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_QImageIOPlugin_disconnectNotify -func miqt_exec_callback_QImageIOPlugin_disconnectNotify(self *C.QImageIOPlugin, 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((&QImageIOPlugin{h: self}).callVirtualBase_DisconnectNotify, slotval1) - -} - // Delete this object from C++ memory. func (this *QImageIOPlugin) Delete() { C.QImageIOPlugin_delete(this.h) diff --git a/qt6/gen_qimageiohandler.h b/qt6/gen_qimageiohandler.h index ba04bcdcf5..4d25a27669 100644 --- a/qt6/gen_qimageiohandler.h +++ b/qt6/gen_qimageiohandler.h @@ -15,8 +15,6 @@ extern "C" { #endif #ifdef __cplusplus -class QChildEvent; -class QEvent; class QIODevice; class QImage; class QImageIOHandler; @@ -26,11 +24,8 @@ class QMetaObject; class QObject; class QRect; class QSize; -class QTimerEvent; class QVariant; #else -typedef struct QChildEvent QChildEvent; -typedef struct QEvent QEvent; typedef struct QIODevice QIODevice; typedef struct QImage QImage; typedef struct QImageIOHandler QImageIOHandler; @@ -40,7 +35,6 @@ typedef struct QMetaObject QMetaObject; typedef struct QObject QObject; typedef struct QRect QRect; typedef struct QSize QSize; -typedef struct QTimerEvent QTimerEvent; typedef struct QVariant QVariant; #endif @@ -94,8 +88,6 @@ QRect* QImageIOHandler_virtualbase_currentImageRect(const void* self); void QImageIOHandler_delete(QImageIOHandler* self); -QImageIOPlugin* QImageIOPlugin_new(); -QImageIOPlugin* QImageIOPlugin_new2(QObject* parent); void QImageIOPlugin_virtbase(QImageIOPlugin* src, QObject** outptr_QObject); QMetaObject* QImageIOPlugin_metaObject(const QImageIOPlugin* self); void* QImageIOPlugin_metacast(QImageIOPlugin* self, const char* param1); @@ -105,30 +97,6 @@ QImageIOHandler* QImageIOPlugin_create(const QImageIOPlugin* self, QIODevice* de struct miqt_string QImageIOPlugin_tr2(const char* s, const char* c); struct miqt_string QImageIOPlugin_tr3(const char* s, const char* c, int n); -bool QImageIOPlugin_override_virtual_capabilities(void* self, intptr_t slot); -int QImageIOPlugin_virtualbase_capabilities(const void* self, QIODevice* device, struct miqt_string format); -bool QImageIOPlugin_override_virtual_create(void* self, intptr_t slot); -QImageIOHandler* QImageIOPlugin_virtualbase_create(const void* self, QIODevice* device, struct miqt_string format); -bool QImageIOPlugin_override_virtual_event(void* self, intptr_t slot); -bool QImageIOPlugin_virtualbase_event(void* self, QEvent* event); -bool QImageIOPlugin_override_virtual_eventFilter(void* self, intptr_t slot); -bool QImageIOPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event); -bool QImageIOPlugin_override_virtual_timerEvent(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event); -bool QImageIOPlugin_override_virtual_childEvent(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_childEvent(void* self, QChildEvent* event); -bool QImageIOPlugin_override_virtual_customEvent(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_customEvent(void* self, QEvent* event); -bool QImageIOPlugin_override_virtual_connectNotify(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal); -bool QImageIOPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot); -void QImageIOPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal); - -QObject* QImageIOPlugin_protectedbase_sender(bool* _dynamic_cast_ok, const void* self); -int QImageIOPlugin_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self); -int QImageIOPlugin_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal); -bool QImageIOPlugin_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal); - void QImageIOPlugin_delete(QImageIOPlugin* self); #ifdef __cplusplus diff --git a/qt6/gen_qimagereader.cpp b/qt6/gen_qimagereader.cpp index 46312b86cc..1660c1eb5a 100644 --- a/qt6/gen_qimagereader.cpp +++ b/qt6/gen_qimagereader.cpp @@ -119,10 +119,10 @@ int QImageReader_imageFormat(const QImageReader* self) { } struct miqt_array /* of struct miqt_string */ QImageReader_textKeys(const QImageReader* self) { - QStringList _ret = self->textKeys(); + QList _ret = self->textKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -133,7 +133,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_textKeys(const QImag _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -219,8 +219,8 @@ struct miqt_string QImageReader_subType(const QImageReader* self) { struct miqt_array /* of struct miqt_string */ QImageReader_supportedSubTypes(const QImageReader* self) { QList _ret = self->supportedSubTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -229,7 +229,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedSubTypes(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -316,8 +316,8 @@ struct miqt_string QImageReader_imageFormatWithDevice(QIODevice* device) { struct miqt_array /* of struct miqt_string */ QImageReader_supportedImageFormats() { QList _ret = QImageReader::supportedImageFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -326,7 +326,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedImageFormat _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -334,8 +334,8 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedImageFormat struct miqt_array /* of struct miqt_string */ QImageReader_supportedMimeTypes() { QList _ret = QImageReader::supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -344,7 +344,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_supportedMimeTypes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -353,8 +353,8 @@ struct miqt_array /* of struct miqt_string */ QImageReader_imageFormatsForMimeT QByteArray mimeType_QByteArray(mimeType.data, mimeType.len); QList _ret = QImageReader::imageFormatsForMimeType(mimeType_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -363,7 +363,7 @@ struct miqt_array /* of struct miqt_string */ QImageReader_imageFormatsForMimeT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qimagewriter.cpp b/qt6/gen_qimagewriter.cpp index b844ca615c..ce61c961bf 100644 --- a/qt6/gen_qimagewriter.cpp +++ b/qt6/gen_qimagewriter.cpp @@ -119,8 +119,8 @@ struct miqt_string QImageWriter_subType(const QImageWriter* self) { struct miqt_array /* of struct miqt_string */ QImageWriter_supportedSubTypes(const QImageWriter* self) { QList _ret = self->supportedSubTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -129,7 +129,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedSubTypes(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -196,8 +196,8 @@ bool QImageWriter_supportsOption(const QImageWriter* self, int option) { struct miqt_array /* of struct miqt_string */ QImageWriter_supportedImageFormats() { QList _ret = QImageWriter::supportedImageFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -206,7 +206,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedImageFormat _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -214,8 +214,8 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedImageFormat struct miqt_array /* of struct miqt_string */ QImageWriter_supportedMimeTypes() { QList _ret = QImageWriter::supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -224,7 +224,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_supportedMimeTypes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -233,8 +233,8 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_imageFormatsForMimeT QByteArray mimeType_QByteArray(mimeType.data, mimeType.len); QList _ret = QImageWriter::imageFormatsForMimeType(mimeType_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -243,7 +243,7 @@ struct miqt_array /* of struct miqt_string */ QImageWriter_imageFormatsForMimeT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qinputdevice.cpp b/qt6/gen_qinputdevice.cpp index 63816ae558..9bbcc4e4a0 100644 --- a/qt6/gen_qinputdevice.cpp +++ b/qt6/gen_qinputdevice.cpp @@ -263,10 +263,10 @@ QRect* QInputDevice_availableVirtualGeometry(const QInputDevice* self) { } struct miqt_array /* of struct miqt_string */ QInputDevice_seatNames() { - QStringList _ret = QInputDevice::seatNames(); + QList _ret = QInputDevice::seatNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -277,20 +277,20 @@ struct miqt_array /* of struct miqt_string */ QInputDevice_seatNames() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QInputDevice* */ QInputDevice_devices() { - QList _ret = QInputDevice::devices(); + QList _ret = QInputDevice::devices(); // Convert QList<> from C++ memory to manually-managed C memory - QInputDevice** _arr = static_cast(malloc(sizeof(QInputDevice*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QInputDevice** _arr = static_cast(malloc(sizeof(QInputDevice*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = (QInputDevice*) _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qinputdialog.cpp b/qt6/gen_qinputdialog.cpp index 064798f9d4..7a96ee7c1a 100644 --- a/qt6/gen_qinputdialog.cpp +++ b/qt6/gen_qinputdialog.cpp @@ -1113,7 +1113,7 @@ bool QInputDialog_isComboBoxEditable(const QInputDialog* self) { } void QInputDialog_setComboBoxItems(QInputDialog* self, struct miqt_array /* of struct miqt_string */ items) { - QStringList items_QList; + QList items_QList; items_QList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -1124,10 +1124,10 @@ void QInputDialog_setComboBoxItems(QInputDialog* self, struct miqt_array /* of s } struct miqt_array /* of struct miqt_string */ QInputDialog_comboBoxItems(const QInputDialog* self) { - QStringList _ret = self->comboBoxItems(); + QList _ret = self->comboBoxItems(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1138,7 +1138,7 @@ struct miqt_array /* of struct miqt_string */ QInputDialog_comboBoxItems(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1288,7 +1288,7 @@ struct miqt_string QInputDialog_getMultiLineText(QWidget* parent, struct miqt_st struct miqt_string QInputDialog_getItem(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; + QList items_QList; items_QList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -1565,7 +1565,7 @@ struct miqt_string QInputDialog_getMultiLineText5(QWidget* parent, struct miqt_s struct miqt_string QInputDialog_getItem2(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; + QList items_QList; items_QList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -1585,7 +1585,7 @@ struct miqt_string QInputDialog_getItem2(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem3(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; + QList items_QList; items_QList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -1605,7 +1605,7 @@ struct miqt_string QInputDialog_getItem3(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem4(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable, bool* ok) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; + QList items_QList; items_QList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -1625,7 +1625,7 @@ struct miqt_string QInputDialog_getItem4(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem5(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable, bool* ok, int flags) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; + QList items_QList; items_QList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -1645,7 +1645,7 @@ struct miqt_string QInputDialog_getItem5(QWidget* parent, struct miqt_string tit struct miqt_string QInputDialog_getItem6(QWidget* parent, struct miqt_string title, struct miqt_string label, struct miqt_array /* of struct miqt_string */ items, int current, bool editable, bool* ok, int flags, int inputMethodHints) { QString title_QString = QString::fromUtf8(title.data, title.len); QString label_QString = QString::fromUtf8(label.data, label.len); - QStringList items_QList; + QList items_QList; items_QList.reserve(items.len); struct miqt_string* items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { diff --git a/qt6/gen_qitemdelegate.cpp b/qt6/gen_qitemdelegate.cpp index 623619bc65..68cf8b1be7 100644 --- a/qt6/gen_qitemdelegate.cpp +++ b/qt6/gen_qitemdelegate.cpp @@ -824,12 +824,12 @@ bool QItemDelegate_override_virtual_paintingRoles(void* self, intptr_t slot) { struct miqt_array /* of int */ QItemDelegate_virtualbase_paintingRoles(const void* self) { QList _ret = static_cast(self)->QItemDelegate::paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qitemselectionmodel.cpp b/qt6/gen_qitemselectionmodel.cpp index cabe2dba6d..21c7cd463f 100644 --- a/qt6/gen_qitemselectionmodel.cpp +++ b/qt6/gen_qitemselectionmodel.cpp @@ -140,14 +140,14 @@ bool QItemSelectionRange_isEmpty(const QItemSelectionRange* self) { } struct miqt_array /* of QModelIndex* */ QItemSelectionRange_indexes(const QItemSelectionRange* self) { - QModelIndexList _ret = self->indexes(); + QList _ret = self->indexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -470,40 +470,40 @@ bool QItemSelectionModel_hasSelection(const QItemSelectionModel* self) { } struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedIndexes(const QItemSelectionModel* self) { - QModelIndexList _ret = self->selectedIndexes(); + QList _ret = self->selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedRows(const QItemSelectionModel* self) { - QModelIndexList _ret = self->selectedRows(); + QList _ret = self->selectedRows(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedColumns(const QItemSelectionModel* self) { - QModelIndexList _ret = self->selectedColumns(); + QList _ret = self->selectedColumns(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -666,27 +666,27 @@ bool QItemSelectionModel_columnIntersectsSelection2(const QItemSelectionModel* s } struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedRowsWithColumn(const QItemSelectionModel* self, int column) { - QModelIndexList _ret = self->selectedRows(static_cast(column)); + QList _ret = self->selectedRows(static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QModelIndex* */ QItemSelectionModel_selectedColumnsWithRow(const QItemSelectionModel* self, int row) { - QModelIndexList _ret = self->selectedColumns(static_cast(row)); + QList _ret = self->selectedColumns(static_cast(row)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -953,14 +953,14 @@ bool QItemSelection_contains(const QItemSelection* self, QModelIndex* index) { } struct miqt_array /* of QModelIndex* */ QItemSelection_indexes(const QItemSelection* self) { - QModelIndexList _ret = self->indexes(); + QList _ret = self->indexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qjsonarray.cpp b/qt6/gen_qjsonarray.cpp index 77f97ecf54..202c63fc71 100644 --- a/qt6/gen_qjsonarray.cpp +++ b/qt6/gen_qjsonarray.cpp @@ -33,7 +33,7 @@ void QJsonArray_operatorAssign(QJsonArray* self, QJsonArray* other) { } QJsonArray* QJsonArray_fromStringList(struct miqt_array /* of struct miqt_string */ list) { - QStringList list_QList; + QList list_QList; list_QList.reserve(list.len); struct miqt_string* list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -44,7 +44,7 @@ QJsonArray* QJsonArray_fromStringList(struct miqt_array /* of struct miqt_string } QJsonArray* QJsonArray_fromVariantList(struct miqt_array /* of QVariant* */ list) { - QVariantList list_QList; + QList list_QList; list_QList.reserve(list.len); QVariant** list_arr = static_cast(list.data); for(size_t i = 0; i < list.len; ++i) { @@ -54,14 +54,14 @@ QJsonArray* QJsonArray_fromVariantList(struct miqt_array /* of QVariant* */ lis } struct miqt_array /* of QVariant* */ QJsonArray_toVariantList(const QJsonArray* self) { - QVariantList _ret = self->toVariantList(); + QList _ret = self->toVariantList(); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qjsonobject.cpp b/qt6/gen_qjsonobject.cpp index cb40fa4227..7642980afd 100644 --- a/qt6/gen_qjsonobject.cpp +++ b/qt6/gen_qjsonobject.cpp @@ -39,7 +39,7 @@ void QJsonObject_swap(QJsonObject* self, QJsonObject* other) { } QJsonObject* QJsonObject_fromVariantMap(struct miqt_map /* of struct miqt_string to QVariant* */ map) { - QVariantMap map_QMap; + QMap map_QMap; struct miqt_string* map_karr = static_cast(map.keys); QVariant** map_varr = static_cast(map.values); for(size_t i = 0; i < map.len; ++i) { @@ -50,7 +50,7 @@ QJsonObject* QJsonObject_fromVariantMap(struct miqt_map /* of struct miqt_string } struct miqt_map /* of struct miqt_string to QVariant* */ QJsonObject_toVariantMap(const QJsonObject* self) { - QVariantMap _ret = self->toVariantMap(); + QMap _ret = self->toVariantMap(); // Convert QMap<> from C++ memory to manually-managed C memory struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); @@ -75,7 +75,7 @@ struct miqt_map /* of struct miqt_string to QVariant* */ QJsonObject_toVariantM } QJsonObject* QJsonObject_fromVariantHash(struct miqt_map /* of struct miqt_string to QVariant* */ map) { - QVariantHash map_QMap; + QHash map_QMap; map_QMap.reserve(map.len); struct miqt_string* map_karr = static_cast(map.keys); QVariant** map_varr = static_cast(map.values); @@ -87,7 +87,7 @@ QJsonObject* QJsonObject_fromVariantHash(struct miqt_map /* of struct miqt_strin } struct miqt_map /* of struct miqt_string to QVariant* */ QJsonObject_toVariantHash(const QJsonObject* self) { - QVariantHash _ret = self->toVariantHash(); + QHash _ret = self->toVariantHash(); // Convert QMap<> from C++ memory to manually-managed C memory struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); @@ -112,10 +112,10 @@ struct miqt_map /* of struct miqt_string to QVariant* */ QJsonObject_toVariantH } struct miqt_array /* of struct miqt_string */ QJsonObject_keys(const QJsonObject* self) { - QStringList _ret = self->keys(); + QList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -126,7 +126,7 @@ struct miqt_array /* of struct miqt_string */ QJsonObject_keys(const QJsonObjec _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qkeysequence.cpp b/qt6/gen_qkeysequence.cpp index 893c63a01b..5f0abe9ff5 100644 --- a/qt6/gen_qkeysequence.cpp +++ b/qt6/gen_qkeysequence.cpp @@ -98,12 +98,12 @@ struct miqt_array /* of QKeySequence* */ QKeySequence_listFromString(struct miq QString str_QString = QString::fromUtf8(str.data, str.len); QList _ret = QKeySequence::listFromString(str_QString); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -138,12 +138,12 @@ QKeySequence* QKeySequence_mnemonic(struct miqt_string text) { struct miqt_array /* of QKeySequence* */ QKeySequence_keyBindings(int key) { QList _ret = QKeySequence::keyBindings(static_cast(key)); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -212,12 +212,12 @@ struct miqt_array /* of QKeySequence* */ QKeySequence_listFromString2(struct mi QString str_QString = QString::fromUtf8(str.data, str.len); QList _ret = QKeySequence::listFromString(str_QString, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qlayoutitem.cpp b/qt6/gen_qlayoutitem.cpp index d0899bf537..789bedccef 100644 --- a/qt6/gen_qlayoutitem.cpp +++ b/qt6/gen_qlayoutitem.cpp @@ -132,7 +132,7 @@ class MiqtVirtualQLayoutItem final : public QLayoutItem { // Subclass to allow providing a Go implementation virtual Qt::Orientations expandingDirections() const override { if (handle__expandingDirections == 0) { - return Qt::Orientations(); // Pure virtual, there is no base we can call + return (Qt::Orientations)(0); // Pure virtual, there is no base we can call } int callback_return_value = miqt_exec_callback_QLayoutItem_expandingDirections(this, handle__expandingDirections); diff --git a/qt6/gen_qlibraryinfo.cpp b/qt6/gen_qlibraryinfo.cpp index 122dfd1e89..17b375cc9b 100644 --- a/qt6/gen_qlibraryinfo.cpp +++ b/qt6/gen_qlibraryinfo.cpp @@ -51,10 +51,10 @@ struct miqt_string QLibraryInfo_location(int location) { struct miqt_array /* of struct miqt_string */ QLibraryInfo_platformPluginArguments(struct miqt_string platformName) { QString platformName_QString = QString::fromUtf8(platformName.data, platformName.len); - QStringList _ret = QLibraryInfo::platformPluginArguments(platformName_QString); + QList _ret = QLibraryInfo::platformPluginArguments(platformName_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -65,7 +65,7 @@ struct miqt_array /* of struct miqt_string */ QLibraryInfo_platformPluginArgume _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qlistview.cpp b/qt6/gen_qlistview.cpp index 7fdfe1d7e7..9224d80ab2 100644 --- a/qt6/gen_qlistview.cpp +++ b/qt6/gen_qlistview.cpp @@ -320,12 +320,12 @@ class MiqtVirtualQListView final : public QListView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QListView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -656,13 +656,13 @@ class MiqtVirtualQListView final : public QListView { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QListView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QListView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1974,7 +1974,7 @@ void QListView_setRootIndex(QListView* self, QModelIndex* index) { } void QListView_indexesMoved(QListView* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1984,15 +1984,15 @@ void QListView_indexesMoved(QListView* self, struct miqt_array /* of QModelIndex } void QListView_connect_indexesMoved(QListView* self, intptr_t slot) { - QListView::connect(self, static_cast(&QListView::indexesMoved), self, [=](const QModelIndexList& indexes) { - const QModelIndexList& indexes_ret = indexes; + QListView::connect(self, static_cast&)>(&QListView::indexesMoved), self, [=](const QList& indexes) { + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; miqt_exec_callback_QListView_indexesMoved(slot, sigval1); @@ -2416,14 +2416,14 @@ bool QListView_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QListView_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QListView::selectedIndexes(); + QList _ret = static_cast(self)->QListView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qlistwidget.cpp b/qt6/gen_qlistwidget.cpp index c52ced4e2f..b6be6f772c 100644 --- a/qt6/gen_qlistwidget.cpp +++ b/qt6/gen_qlistwidget.cpp @@ -687,13 +687,13 @@ class MiqtVirtualQListWidget final : public QListWidget { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QListWidget::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QListWidget_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -709,19 +709,19 @@ class MiqtVirtualQListWidget final : public QListWidget { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QList& items) const override { + virtual QMimeData* mimeData(const QList& items) const override { if (handle__mimeData == 0) { return QListWidget::mimeData(items); } - const QList& items_ret = items; + const QList& items_ret = items; // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** items_arr = static_cast(malloc(sizeof(QListWidgetItem*) * items_ret.length())); - for (size_t i = 0, e = items_ret.length(); i < e; ++i) { + QListWidgetItem** items_arr = static_cast(malloc(sizeof(QListWidgetItem*) * items_ret.size())); + for (size_t i = 0, e = items_ret.size(); i < e; ++i) { items_arr[i] = items_ret[i]; } struct miqt_array items_out; - items_out.len = items_ret.length(); + items_out.len = items_ret.size(); items_out.data = static_cast(items_arr); struct miqt_array /* of QListWidgetItem* */ sigval1 = items_out; QMimeData* callback_return_value = miqt_exec_callback_QListWidget_mimeData(this, handle__mimeData, sigval1); @@ -908,12 +908,12 @@ class MiqtVirtualQListWidget final : public QListWidget { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QListWidget_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -1227,13 +1227,13 @@ class MiqtVirtualQListWidget final : public QListWidget { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QListWidget::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QListWidget_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -2378,7 +2378,7 @@ void QListWidget_insertItem2(QListWidget* self, int row, struct miqt_string labe } void QListWidget_insertItems(QListWidget* self, int row, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; + QList labels_QList; labels_QList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { @@ -2398,7 +2398,7 @@ void QListWidget_addItemWithItem(QListWidget* self, QListWidgetItem* item) { } void QListWidget_addItems(QListWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; + QList labels_QList; labels_QList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { @@ -2493,41 +2493,41 @@ void QListWidget_removeItemWidget(QListWidget* self, QListWidgetItem* item) { } struct miqt_array /* of QListWidgetItem* */ QListWidget_selectedItems(const QListWidget* self) { - QList _ret = self->selectedItems(); + QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QListWidgetItem* */ QListWidget_findItems(const QListWidget* self, struct miqt_string text, int flags) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->findItems(text_QString, static_cast(flags)); + QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QListWidgetItem* */ QListWidget_items(const QListWidget* self, QMimeData* data) { - QList _ret = self->items(data); + QList _ret = self->items(data); // Convert QList<> from C++ memory to manually-managed C memory - QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QListWidgetItem** _arr = static_cast(malloc(sizeof(QListWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2749,10 +2749,10 @@ bool QListWidget_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QListWidget_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QListWidget::mimeTypes(); + QList _ret = static_cast(self)->QListWidget::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2763,7 +2763,7 @@ struct miqt_array /* of struct miqt_string */ QListWidget_virtualbase_mimeTypes _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2779,7 +2779,7 @@ bool QListWidget_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QListWidget_virtualbase_mimeData(const void* self, struct miqt_array /* of QListWidgetItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QListWidgetItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -3184,14 +3184,14 @@ bool QListWidget_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QListWidget_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QListWidget::selectedIndexes(); + QList _ret = static_cast(self)->QListWidget::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qlocale.cpp b/qt6/gen_qlocale.cpp index c2ee10dfb5..5633f160ac 100644 --- a/qt6/gen_qlocale.cpp +++ b/qt6/gen_qlocale.cpp @@ -603,13 +603,13 @@ int QLocale_firstDayOfWeek(const QLocale* self) { struct miqt_array /* of int */ QLocale_weekdays(const QLocale* self) { QList _ret = self->weekdays(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { Qt::DayOfWeek _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -785,10 +785,10 @@ struct miqt_string QLocale_formattedDataSize(const QLocale* self, long long byte } struct miqt_array /* of struct miqt_string */ QLocale_uiLanguages(const QLocale* self) { - QStringList _ret = self->uiLanguages(); + QList _ret = self->uiLanguages(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -799,7 +799,7 @@ struct miqt_array /* of struct miqt_string */ QLocale_uiLanguages(const QLocale _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -907,12 +907,12 @@ QLocale* QLocale_system() { struct miqt_array /* of QLocale* */ QLocale_matchingLocales(unsigned short language, unsigned short script, unsigned short territory) { QList _ret = QLocale::matchingLocales(static_cast(language), static_cast(script), static_cast(territory)); // Convert QList<> from C++ memory to manually-managed C memory - QLocale** _arr = static_cast(malloc(sizeof(QLocale*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QLocale** _arr = static_cast(malloc(sizeof(QLocale*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QLocale(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -920,13 +920,13 @@ struct miqt_array /* of QLocale* */ QLocale_matchingLocales(unsigned short lang struct miqt_array /* of unsigned short */ QLocale_countriesForLanguage(unsigned short lang) { QList _ret = QLocale::countriesForLanguage(static_cast(lang)); // Convert QList<> from C++ memory to manually-managed C memory - unsigned short* _arr = static_cast(malloc(sizeof(unsigned short) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned short* _arr = static_cast(malloc(sizeof(unsigned short) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QLocale::Country _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -953,7 +953,7 @@ struct miqt_string QLocale_quoteString(const QLocale* self, struct miqt_string s } struct miqt_string QLocale_createSeparatedList(const QLocale* self, struct miqt_array /* of struct miqt_string */ strl) { - QStringList strl_QList; + QList strl_QList; strl_QList.reserve(strl.len); struct miqt_string* strl_arr = static_cast(strl.data); for(size_t i = 0; i < strl.len; ++i) { diff --git a/qt6/gen_qmainwindow.cpp b/qt6/gen_qmainwindow.cpp index d8519e91fe..bbb9e944ea 100644 --- a/qt6/gen_qmainwindow.cpp +++ b/qt6/gen_qmainwindow.cpp @@ -1140,14 +1140,14 @@ void QMainWindow_tabifyDockWidget(QMainWindow* self, QDockWidget* first, QDockWi } struct miqt_array /* of QDockWidget* */ QMainWindow_tabifiedDockWidgets(const QMainWindow* self, QDockWidget* dockwidget) { - QList _ret = self->tabifiedDockWidgets(dockwidget); + QList _ret = self->tabifiedDockWidgets(dockwidget); // Convert QList<> from C++ memory to manually-managed C memory - QDockWidget** _arr = static_cast(malloc(sizeof(QDockWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDockWidget** _arr = static_cast(malloc(sizeof(QDockWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1166,7 +1166,7 @@ int QMainWindow_dockWidgetArea(const QMainWindow* self, QDockWidget* dockwidget) } void QMainWindow_resizeDocks(QMainWindow* self, struct miqt_array /* of QDockWidget* */ docks, struct miqt_array /* of int */ sizes, int orientation) { - QList docks_QList; + QList docks_QList; docks_QList.reserve(docks.len); QDockWidget** docks_arr = static_cast(docks.data); for(size_t i = 0; i < docks.len; ++i) { diff --git a/qt6/gen_qmdiarea.cpp b/qt6/gen_qmdiarea.cpp index 0b92895d36..db4e6bdfa6 100644 --- a/qt6/gen_qmdiarea.cpp +++ b/qt6/gen_qmdiarea.cpp @@ -1054,14 +1054,14 @@ QMdiSubWindow* QMdiArea_activeSubWindow(const QMdiArea* self) { } struct miqt_array /* of QMdiSubWindow* */ QMdiArea_subWindowList(const QMdiArea* self) { - QList _ret = self->subWindowList(); + QList _ret = self->subWindowList(); // Convert QList<> from C++ memory to manually-managed C memory - QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1212,14 +1212,14 @@ struct miqt_string QMdiArea_tr3(const char* s, const char* c, int n) { } struct miqt_array /* of QMdiSubWindow* */ QMdiArea_subWindowListWithOrder(const QMdiArea* self, int order) { - QList _ret = self->subWindowList(static_cast(order)); + QList _ret = self->subWindowList(static_cast(order)); // Convert QList<> from C++ memory to manually-managed C memory - QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMdiSubWindow** _arr = static_cast(malloc(sizeof(QMdiSubWindow*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qmenu.cpp b/qt6/gen_qmenu.cpp index 839d6a0d57..ea030ae438 100644 --- a/qt6/gen_qmenu.cpp +++ b/qt6/gen_qmenu.cpp @@ -1086,7 +1086,7 @@ QAction* QMenu_execWithPos(QMenu* self, QPoint* pos) { } QAction* QMenu_exec2(struct miqt_array /* of QAction* */ actions, QPoint* pos) { - QList actions_QList; + QList actions_QList; actions_QList.reserve(actions.len); QAction** actions_arr = static_cast(actions.data); for(size_t i = 0; i < actions.len; ++i) { @@ -1232,7 +1232,7 @@ QAction* QMenu_exec3(QMenu* self, QPoint* pos, QAction* at) { } QAction* QMenu_exec4(struct miqt_array /* of QAction* */ actions, QPoint* pos, QAction* at) { - QList actions_QList; + QList actions_QList; actions_QList.reserve(actions.len); QAction** actions_arr = static_cast(actions.data); for(size_t i = 0; i < actions.len; ++i) { @@ -1242,7 +1242,7 @@ QAction* QMenu_exec4(struct miqt_array /* of QAction* */ actions, QPoint* pos, } QAction* QMenu_exec5(struct miqt_array /* of QAction* */ actions, QPoint* pos, QAction* at, QWidget* parent) { - QList actions_QList; + QList actions_QList; actions_QList.reserve(actions.len); QAction** actions_arr = static_cast(actions.data); for(size_t i = 0; i < actions.len; ++i) { diff --git a/qt6/gen_qmessagebox.cpp b/qt6/gen_qmessagebox.cpp index f9eddb8146..f5934bf249 100644 --- a/qt6/gen_qmessagebox.cpp +++ b/qt6/gen_qmessagebox.cpp @@ -1098,14 +1098,14 @@ void QMessageBox_removeButton(QMessageBox* self, QAbstractButton* button) { } struct miqt_array /* of QAbstractButton* */ QMessageBox_buttons(const QMessageBox* self) { - QList _ret = self->buttons(); + QList _ret = self->buttons(); // Convert QList<> from C++ memory to manually-managed C memory - QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAbstractButton** _arr = static_cast(malloc(sizeof(QAbstractButton*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qmetaobject.cpp b/qt6/gen_qmetaobject.cpp index 7043b6c517..8cd3cd1f79 100644 --- a/qt6/gen_qmetaobject.cpp +++ b/qt6/gen_qmetaobject.cpp @@ -79,8 +79,8 @@ void QMetaMethod_getParameterTypes(const QMetaMethod* self, int* types) { struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterTypes(const QMetaMethod* self) { QList _ret = self->parameterTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -89,7 +89,7 @@ struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterTypes(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -106,8 +106,8 @@ struct miqt_string QMetaMethod_parameterTypeName(const QMetaMethod* self, int in struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterNames(const QMetaMethod* self) { QList _ret = self->parameterNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -116,7 +116,7 @@ struct miqt_array /* of struct miqt_string */ QMetaMethod_parameterNames(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qmimedata.cpp b/qt6/gen_qmimedata.cpp index 8411be6d2a..25dc1f9000 100644 --- a/qt6/gen_qmimedata.cpp +++ b/qt6/gen_qmimedata.cpp @@ -68,13 +68,13 @@ class MiqtVirtualQMimeData final : public QMimeData { intptr_t handle__formats = 0; // Subclass to allow providing a Go implementation - virtual QStringList formats() const override { + virtual QList formats() const override { if (handle__formats == 0) { return QMimeData::formats(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QMimeData_formats(this, handle__formats); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -269,12 +269,12 @@ struct miqt_string QMimeData_tr(const char* s) { struct miqt_array /* of QUrl* */ QMimeData_urls(const QMimeData* self) { QList _ret = self->urls(); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -384,10 +384,10 @@ bool QMimeData_hasFormat(const QMimeData* self, struct miqt_string mimetype) { } struct miqt_array /* of struct miqt_string */ QMimeData_formats(const QMimeData* self) { - QStringList _ret = self->formats(); + QList _ret = self->formats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -398,7 +398,7 @@ struct miqt_array /* of struct miqt_string */ QMimeData_formats(const QMimeData _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -455,10 +455,10 @@ bool QMimeData_override_virtual_formats(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QMimeData_virtualbase_formats(const void* self) { - QStringList _ret = static_cast(self)->QMimeData::formats(); + QList _ret = static_cast(self)->QMimeData::formats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -469,7 +469,7 @@ struct miqt_array /* of struct miqt_string */ QMimeData_virtualbase_formats(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qmimedatabase.cpp b/qt6/gen_qmimedatabase.cpp index 225158ff1a..076efda49f 100644 --- a/qt6/gen_qmimedatabase.cpp +++ b/qt6/gen_qmimedatabase.cpp @@ -41,12 +41,12 @@ struct miqt_array /* of QMimeType* */ QMimeDatabase_mimeTypesForFileName(const QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); QList _ret = self->mimeTypesForFileName(fileName_QString); // Convert QList<> from C++ memory to manually-managed C memory - QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMimeType(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -90,12 +90,12 @@ struct miqt_string QMimeDatabase_suffixForFileName(const QMimeDatabase* self, st struct miqt_array /* of QMimeType* */ QMimeDatabase_allMimeTypes(const QMimeDatabase* self) { QList _ret = self->allMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMimeType** _arr = static_cast(malloc(sizeof(QMimeType*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMimeType(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qmimetype.cpp b/qt6/gen_qmimetype.cpp index 2da58953b4..a2b6acf284 100644 --- a/qt6/gen_qmimetype.cpp +++ b/qt6/gen_qmimetype.cpp @@ -91,10 +91,10 @@ struct miqt_string QMimeType_iconName(const QMimeType* self) { } struct miqt_array /* of struct miqt_string */ QMimeType_globPatterns(const QMimeType* self) { - QStringList _ret = self->globPatterns(); + QList _ret = self->globPatterns(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -105,16 +105,16 @@ struct miqt_array /* of struct miqt_string */ QMimeType_globPatterns(const QMim _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QMimeType_parentMimeTypes(const QMimeType* self) { - QStringList _ret = self->parentMimeTypes(); + QList _ret = self->parentMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -125,16 +125,16 @@ struct miqt_array /* of struct miqt_string */ QMimeType_parentMimeTypes(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QMimeType_allAncestors(const QMimeType* self) { - QStringList _ret = self->allAncestors(); + QList _ret = self->allAncestors(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -145,16 +145,16 @@ struct miqt_array /* of struct miqt_string */ QMimeType_allAncestors(const QMim _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QMimeType_aliases(const QMimeType* self) { - QStringList _ret = self->aliases(); + QList _ret = self->aliases(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -165,16 +165,16 @@ struct miqt_array /* of struct miqt_string */ QMimeType_aliases(const QMimeType _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QMimeType_suffixes(const QMimeType* self) { - QStringList _ret = self->suffixes(); + QList _ret = self->suffixes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -185,7 +185,7 @@ struct miqt_array /* of struct miqt_string */ QMimeType_suffixes(const QMimeTyp _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qmovie.cpp b/qt6/gen_qmovie.cpp index 2f48501b2c..6ebf3b4f69 100644 --- a/qt6/gen_qmovie.cpp +++ b/qt6/gen_qmovie.cpp @@ -249,8 +249,8 @@ struct miqt_string QMovie_tr(const char* s) { struct miqt_array /* of struct miqt_string */ QMovie_supportedFormats() { QList _ret = QMovie::supportedFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -259,7 +259,7 @@ struct miqt_array /* of struct miqt_string */ QMovie_supportedFormats() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qobject.cpp b/qt6/gen_qobject.cpp index 70b8cf2c9d..9920a34798 100644 --- a/qt6/gen_qobject.cpp +++ b/qt6/gen_qobject.cpp @@ -275,14 +275,14 @@ void QObject_killTimer(QObject* self, int id) { } struct miqt_array /* of QObject* */ QObject_children(const QObject* self) { - const QObjectList& _ret = self->children(); + const QList& _ret = self->children(); // Convert QList<> from C++ memory to manually-managed C memory - QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -334,8 +334,8 @@ QVariant* QObject_property(const QObject* self, const char* name) { struct miqt_array /* of struct miqt_string */ QObject_dynamicPropertyNames(const QObject* self) { QList _ret = self->dynamicPropertyNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -344,7 +344,7 @@ struct miqt_array /* of struct miqt_string */ QObject_dynamicPropertyNames(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qpageranges.cpp b/qt6/gen_qpageranges.cpp index 9b21421f3f..a9d3c329a7 100644 --- a/qt6/gen_qpageranges.cpp +++ b/qt6/gen_qpageranges.cpp @@ -42,12 +42,12 @@ void QPageRanges_addRange(QPageRanges* self, int from, int to) { struct miqt_array /* of QPageRanges__Range* */ QPageRanges_toRangeList(const QPageRanges* self) { QList _ret = self->toRangeList(); // Convert QList<> from C++ memory to manually-managed C memory - QPageRanges__Range** _arr = static_cast(malloc(sizeof(QPageRanges__Range*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPageRanges__Range** _arr = static_cast(malloc(sizeof(QPageRanges__Range*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPageRanges::Range(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qpainterpath.cpp b/qt6/gen_qpainterpath.cpp index 3273271546..89b79279de 100644 --- a/qt6/gen_qpainterpath.cpp +++ b/qt6/gen_qpainterpath.cpp @@ -386,7 +386,7 @@ void QPainterPathStroker_setDashPattern(QPainterPathStroker* self, int dashPatte } void QPainterPathStroker_setDashPatternWithDashPattern(QPainterPathStroker* self, struct miqt_array /* of double */ dashPattern) { - QList dashPattern_QList; + QList dashPattern_QList; dashPattern_QList.reserve(dashPattern.len); double* dashPattern_arr = static_cast(dashPattern.data); for(size_t i = 0; i < dashPattern.len; ++i) { @@ -396,14 +396,14 @@ void QPainterPathStroker_setDashPatternWithDashPattern(QPainterPathStroker* self } struct miqt_array /* of double */ QPainterPathStroker_dashPattern(const QPainterPathStroker* self) { - QList _ret = self->dashPattern(); + QList _ret = self->dashPattern(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qpen.cpp b/qt6/gen_qpen.cpp index 7244e0513f..9a546c2e97 100644 --- a/qt6/gen_qpen.cpp +++ b/qt6/gen_qpen.cpp @@ -64,20 +64,20 @@ void QPen_setStyle(QPen* self, int style) { } struct miqt_array /* of double */ QPen_dashPattern(const QPen* self) { - QList _ret = self->dashPattern(); + QList _ret = self->dashPattern(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QPen_setDashPattern(QPen* self, struct miqt_array /* of double */ pattern) { - QList pattern_QList; + QList pattern_QList; pattern_QList.reserve(pattern.len); double* pattern_arr = static_cast(pattern.data); for(size_t i = 0; i < pattern.len; ++i) { diff --git a/qt6/gen_qplaintextedit.cpp b/qt6/gen_qplaintextedit.cpp index d762310b0b..08ca7d4308 100644 --- a/qt6/gen_qplaintextedit.cpp +++ b/qt6/gen_qplaintextedit.cpp @@ -1421,12 +1421,12 @@ void QPlainTextEdit_setExtraSelections(QPlainTextEdit* self, struct miqt_array / struct miqt_array /* of QTextEdit__ExtraSelection* */ QPlainTextEdit_extraSelections(const QPlainTextEdit* self) { QList _ret = self->extraSelections(); // Convert QList<> from C++ memory to manually-managed C memory - QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextEdit::ExtraSelection(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qpluginloader.cpp b/qt6/gen_qpluginloader.cpp index c3a3fb9c5e..38f1bde7c0 100644 --- a/qt6/gen_qpluginloader.cpp +++ b/qt6/gen_qpluginloader.cpp @@ -218,14 +218,14 @@ QJsonObject* QPluginLoader_metaData(const QPluginLoader* self) { } struct miqt_array /* of QObject* */ QPluginLoader_staticInstances() { - QObjectList _ret = QPluginLoader::staticInstances(); + QList _ret = QPluginLoader::staticInstances(); // Convert QList<> from C++ memory to manually-managed C memory - QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -233,12 +233,12 @@ struct miqt_array /* of QObject* */ QPluginLoader_staticInstances() { struct miqt_array /* of QStaticPlugin* */ QPluginLoader_staticPlugins() { QList _ret = QPluginLoader::staticPlugins(); // Convert QList<> from C++ memory to manually-managed C memory - QStaticPlugin** _arr = static_cast(malloc(sizeof(QStaticPlugin*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStaticPlugin** _arr = static_cast(malloc(sizeof(QStaticPlugin*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QStaticPlugin(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qprocess.cpp b/qt6/gen_qprocess.cpp index 36138babd7..0da3875dca 100644 --- a/qt6/gen_qprocess.cpp +++ b/qt6/gen_qprocess.cpp @@ -124,10 +124,10 @@ struct miqt_string QProcessEnvironment_value(const QProcessEnvironment* self, st } struct miqt_array /* of struct miqt_string */ QProcessEnvironment_toStringList(const QProcessEnvironment* self) { - QStringList _ret = self->toStringList(); + QList _ret = self->toStringList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -138,16 +138,16 @@ struct miqt_array /* of struct miqt_string */ QProcessEnvironment_toStringList( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QProcessEnvironment_keys(const QProcessEnvironment* self) { - QStringList _ret = self->keys(); + QList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -158,7 +158,7 @@ struct miqt_array /* of struct miqt_string */ QProcessEnvironment_keys(const QP _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -671,10 +671,10 @@ void QProcess_setProgram(QProcess* self, struct miqt_string program) { } struct miqt_array /* of struct miqt_string */ QProcess_arguments(const QProcess* self) { - QStringList _ret = self->arguments(); + QList _ret = self->arguments(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -685,13 +685,13 @@ struct miqt_array /* of struct miqt_string */ QProcess_arguments(const QProcess _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QProcess_setArguments(QProcess* self, struct miqt_array /* of struct miqt_string */ arguments) { - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -772,7 +772,7 @@ void QProcess_setWorkingDirectory(QProcess* self, struct miqt_string dir) { } void QProcess_setEnvironment(QProcess* self, struct miqt_array /* of struct miqt_string */ environment) { - QStringList environment_QList; + QList environment_QList; environment_QList.reserve(environment.len); struct miqt_string* environment_arr = static_cast(environment.data); for(size_t i = 0; i < environment.len; ++i) { @@ -783,10 +783,10 @@ void QProcess_setEnvironment(QProcess* self, struct miqt_array /* of struct miqt } struct miqt_array /* of struct miqt_string */ QProcess_environment(const QProcess* self) { - QStringList _ret = self->environment(); + QList _ret = self->environment(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -797,7 +797,7 @@ struct miqt_array /* of struct miqt_string */ QProcess_environment(const QProce _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -892,10 +892,10 @@ bool QProcess_startDetachedWithProgram(struct miqt_string program) { } struct miqt_array /* of struct miqt_string */ QProcess_systemEnvironment() { - QStringList _ret = QProcess::systemEnvironment(); + QList _ret = QProcess::systemEnvironment(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -906,7 +906,7 @@ struct miqt_array /* of struct miqt_string */ QProcess_systemEnvironment() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -977,7 +977,7 @@ struct miqt_string QProcess_tr3(const char* s, const char* c, int n) { void QProcess_start3(QProcess* self, struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -989,7 +989,7 @@ void QProcess_start3(QProcess* self, struct miqt_string program, struct miqt_arr void QProcess_start4(QProcess* self, struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments, int mode) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -1032,7 +1032,7 @@ bool QProcess_waitForFinishedWithMsecs(QProcess* self, int msecs) { int QProcess_execute2(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -1044,7 +1044,7 @@ int QProcess_execute2(struct miqt_string program, struct miqt_array /* of struct bool QProcess_startDetached2(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -1056,7 +1056,7 @@ bool QProcess_startDetached2(struct miqt_string program, struct miqt_array /* of bool QProcess_startDetached3(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments, struct miqt_string workingDirectory) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -1069,7 +1069,7 @@ bool QProcess_startDetached3(struct miqt_string program, struct miqt_array /* of bool QProcess_startDetached4(struct miqt_string program, struct miqt_array /* of struct miqt_string */ arguments, struct miqt_string workingDirectory, long long* pid) { QString program_QString = QString::fromUtf8(program.data, program.len); - QStringList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); struct miqt_string* arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { diff --git a/qt6/gen_qrawfont.cpp b/qt6/gen_qrawfont.cpp index a03bd81575..e5ce36da04 100644 --- a/qt6/gen_qrawfont.cpp +++ b/qt6/gen_qrawfont.cpp @@ -103,20 +103,20 @@ int QRawFont_weight(const QRawFont* self) { struct miqt_array /* of unsigned int */ QRawFont_glyphIndexesForString(const QRawFont* self, struct miqt_string text) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->glyphIndexesForString(text_QString); + QList _ret = self->glyphIndexesForString(text_QString); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QPointF* */ QRawFont_advancesForGlyphIndexes(const QRawFont* self, struct miqt_array /* of unsigned int */ glyphIndexes) { - QList glyphIndexes_QList; + QList glyphIndexes_QList; glyphIndexes_QList.reserve(glyphIndexes.len); unsigned int* glyphIndexes_arr = static_cast(glyphIndexes.data); for(size_t i = 0; i < glyphIndexes.len; ++i) { @@ -124,18 +124,18 @@ struct miqt_array /* of QPointF* */ QRawFont_advancesForGlyphIndexes(const QRaw } QList _ret = self->advancesForGlyphIndexes(glyphIndexes_QList); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QPointF* */ QRawFont_advancesForGlyphIndexes2(const QRawFont* self, struct miqt_array /* of unsigned int */ glyphIndexes, int layoutFlags) { - QList glyphIndexes_QList; + QList glyphIndexes_QList; glyphIndexes_QList.reserve(glyphIndexes.len); unsigned int* glyphIndexes_arr = static_cast(glyphIndexes.data); for(size_t i = 0; i < glyphIndexes.len; ++i) { @@ -143,12 +143,12 @@ struct miqt_array /* of QPointF* */ QRawFont_advancesForGlyphIndexes2(const QRa } QList _ret = self->advancesForGlyphIndexes(glyphIndexes_QList, static_cast(layoutFlags)); // Convert QList<> from C++ memory to manually-managed C memory - QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPointF** _arr = static_cast(malloc(sizeof(QPointF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPointF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -262,13 +262,13 @@ bool QRawFont_supportsCharacterWithCharacter(const QRawFont* self, QChar* charac struct miqt_array /* of int */ QRawFont_supportedWritingSystems(const QRawFont* self) { QList _ret = self->supportedWritingSystems(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QFontDatabase::WritingSystem _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qregularexpression.cpp b/qt6/gen_qregularexpression.cpp index 69c239553f..99c7abf4ae 100644 --- a/qt6/gen_qregularexpression.cpp +++ b/qt6/gen_qregularexpression.cpp @@ -92,10 +92,10 @@ int QRegularExpression_captureCount(const QRegularExpression* self) { } struct miqt_array /* of struct miqt_string */ QRegularExpression_namedCaptureGroups(const QRegularExpression* self) { - QStringList _ret = self->namedCaptureGroups(); + QList _ret = self->namedCaptureGroups(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -106,7 +106,7 @@ struct miqt_array /* of struct miqt_string */ QRegularExpression_namedCaptureGr _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -294,10 +294,10 @@ struct miqt_string QRegularExpressionMatch_capturedWithName(const QRegularExpres } struct miqt_array /* of struct miqt_string */ QRegularExpressionMatch_capturedTexts(const QRegularExpressionMatch* self) { - QStringList _ret = self->capturedTexts(); + QList _ret = self->capturedTexts(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -308,7 +308,7 @@ struct miqt_array /* of struct miqt_string */ QRegularExpressionMatch_capturedT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qscreen.cpp b/qt6/gen_qscreen.cpp index d21bbd1d9c..9cffb68b14 100644 --- a/qt6/gen_qscreen.cpp +++ b/qt6/gen_qscreen.cpp @@ -159,14 +159,14 @@ QRect* QScreen_availableGeometry(const QScreen* self) { } struct miqt_array /* of QScreen* */ QScreen_virtualSiblings(const QScreen* self) { - QList _ret = self->virtualSiblings(); + QList _ret = self->virtualSiblings(); // Convert QList<> from C++ memory to manually-managed C memory - QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QScreen** _arr = static_cast(malloc(sizeof(QScreen*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qscroller.cpp b/qt6/gen_qscroller.cpp index ed1fd87267..27070f8d4f 100644 --- a/qt6/gen_qscroller.cpp +++ b/qt6/gen_qscroller.cpp @@ -72,14 +72,14 @@ void QScroller_ungrabGesture(QObject* target) { } struct miqt_array /* of QScroller* */ QScroller_activeScrollers() { - QList _ret = QScroller::activeScrollers(); + QList _ret = QScroller::activeScrollers(); // Convert QList<> from C++ memory to manually-managed C memory - QScroller** _arr = static_cast(malloc(sizeof(QScroller*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QScroller** _arr = static_cast(malloc(sizeof(QScroller*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -118,7 +118,7 @@ QScrollerProperties* QScroller_scrollerProperties(const QScroller* self) { } void QScroller_setSnapPositionsX(QScroller* self, struct miqt_array /* of double */ positions) { - QList positions_QList; + QList positions_QList; positions_QList.reserve(positions.len); double* positions_arr = static_cast(positions.data); for(size_t i = 0; i < positions.len; ++i) { @@ -132,7 +132,7 @@ void QScroller_setSnapPositionsX2(QScroller* self, double first, double interval } void QScroller_setSnapPositionsY(QScroller* self, struct miqt_array /* of double */ positions) { - QList positions_QList; + QList positions_QList; positions_QList.reserve(positions.len); double* positions_arr = static_cast(positions.data); for(size_t i = 0; i < positions.len; ++i) { diff --git a/qt6/gen_qsessionmanager.cpp b/qt6/gen_qsessionmanager.cpp index 04f6094a94..6beab51011 100644 --- a/qt6/gen_qsessionmanager.cpp +++ b/qt6/gen_qsessionmanager.cpp @@ -88,7 +88,7 @@ int QSessionManager_restartHint(const QSessionManager* self) { } void QSessionManager_setRestartCommand(QSessionManager* self, struct miqt_array /* of struct miqt_string */ restartCommand) { - QStringList restartCommand_QList; + QList restartCommand_QList; restartCommand_QList.reserve(restartCommand.len); struct miqt_string* restartCommand_arr = static_cast(restartCommand.data); for(size_t i = 0; i < restartCommand.len; ++i) { @@ -99,10 +99,10 @@ void QSessionManager_setRestartCommand(QSessionManager* self, struct miqt_array } struct miqt_array /* of struct miqt_string */ QSessionManager_restartCommand(const QSessionManager* self) { - QStringList _ret = self->restartCommand(); + QList _ret = self->restartCommand(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -113,13 +113,13 @@ struct miqt_array /* of struct miqt_string */ QSessionManager_restartCommand(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QSessionManager_setDiscardCommand(QSessionManager* self, struct miqt_array /* of struct miqt_string */ discardCommand) { - QStringList discardCommand_QList; + QList discardCommand_QList; discardCommand_QList.reserve(discardCommand.len); struct miqt_string* discardCommand_arr = static_cast(discardCommand.data); for(size_t i = 0; i < discardCommand.len; ++i) { @@ -130,10 +130,10 @@ void QSessionManager_setDiscardCommand(QSessionManager* self, struct miqt_array } struct miqt_array /* of struct miqt_string */ QSessionManager_discardCommand(const QSessionManager* self) { - QStringList _ret = self->discardCommand(); + QList _ret = self->discardCommand(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -144,7 +144,7 @@ struct miqt_array /* of struct miqt_string */ QSessionManager_discardCommand(co _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -157,7 +157,7 @@ void QSessionManager_setManagerProperty(QSessionManager* self, struct miqt_strin void QSessionManager_setManagerProperty2(QSessionManager* self, struct miqt_string name, struct miqt_array /* of struct miqt_string */ value) { QString name_QString = QString::fromUtf8(name.data, name.len); - QStringList value_QList; + QList value_QList; value_QList.reserve(value.len); struct miqt_string* value_arr = static_cast(value.data); for(size_t i = 0; i < value.len; ++i) { diff --git a/qt6/gen_qsettings.cpp b/qt6/gen_qsettings.cpp index e09d161b6a..45a6bd5005 100644 --- a/qt6/gen_qsettings.cpp +++ b/qt6/gen_qsettings.cpp @@ -336,10 +336,10 @@ void QSettings_setArrayIndex(QSettings* self, int i) { } struct miqt_array /* of struct miqt_string */ QSettings_allKeys(const QSettings* self) { - QStringList _ret = self->allKeys(); + QList _ret = self->allKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -350,16 +350,16 @@ struct miqt_array /* of struct miqt_string */ QSettings_allKeys(const QSettings _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QSettings_childKeys(const QSettings* self) { - QStringList _ret = self->childKeys(); + QList _ret = self->childKeys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -370,16 +370,16 @@ struct miqt_array /* of struct miqt_string */ QSettings_childKeys(const QSettin _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QSettings_childGroups(const QSettings* self) { - QStringList _ret = self->childGroups(); + QList _ret = self->childGroups(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -390,7 +390,7 @@ struct miqt_array /* of struct miqt_string */ QSettings_childGroups(const QSett _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qshortcut.cpp b/qt6/gen_qshortcut.cpp index f096df9cfb..430c6234d7 100644 --- a/qt6/gen_qshortcut.cpp +++ b/qt6/gen_qshortcut.cpp @@ -258,12 +258,12 @@ void QShortcut_setKeysWithKeys(QShortcut* self, struct miqt_array /* of QKeySequ struct miqt_array /* of QKeySequence* */ QShortcut_keys(const QShortcut* self) { QList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QKeySequence** _arr = static_cast(malloc(sizeof(QKeySequence*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QKeySequence(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qsortfilterproxymodel.cpp b/qt6/gen_qsortfilterproxymodel.cpp index 12ef4be6db..4c81b1fa52 100644 --- a/qt6/gen_qsortfilterproxymodel.cpp +++ b/qt6/gen_qsortfilterproxymodel.cpp @@ -447,19 +447,19 @@ class MiqtVirtualQSortFilterProxyModel final : public QSortFilterProxyModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QSortFilterProxyModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QSortFilterProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -648,7 +648,7 @@ class MiqtVirtualQSortFilterProxyModel final : public QSortFilterProxyModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QSortFilterProxyModel::match(start, role, value, hits, flags); } @@ -664,7 +664,7 @@ class MiqtVirtualQSortFilterProxyModel final : public QSortFilterProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QSortFilterProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -716,13 +716,13 @@ class MiqtVirtualQSortFilterProxyModel final : public QSortFilterProxyModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QSortFilterProxyModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QSortFilterProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1355,7 +1355,7 @@ bool QSortFilterProxyModel_setHeaderData(QSortFilterProxyModel* self, int sectio } QMimeData* QSortFilterProxyModel_mimeData(const QSortFilterProxyModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1402,14 +1402,14 @@ QModelIndex* QSortFilterProxyModel_buddy(const QSortFilterProxyModel* self, QMod } struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_match(const QSortFilterProxyModel* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = self->match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1423,10 +1423,10 @@ void QSortFilterProxyModel_sort(QSortFilterProxyModel* self, int column, int ord } struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_mimeTypes(const QSortFilterProxyModel* self) { - QStringList _ret = self->mimeTypes(); + QList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1437,7 +1437,7 @@ struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_mimeTypes(c _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1822,7 +1822,7 @@ bool QSortFilterProxyModel_override_virtual_mimeData(void* self, intptr_t slot) } QMimeData* QSortFilterProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1969,14 +1969,14 @@ bool QSortFilterProxyModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QSortFilterProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QSortFilterProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2020,10 +2020,10 @@ bool QSortFilterProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) } struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QSortFilterProxyModel::mimeTypes(); + QList _ret = static_cast(self)->QSortFilterProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2034,7 +2034,7 @@ struct miqt_array /* of struct miqt_string */ QSortFilterProxyModel_virtualbase _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2423,7 +2423,7 @@ void QSortFilterProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, cons } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2616,13 +2616,13 @@ void QSortFilterProxyModel_protectedbase_changePersistentIndexList(bool* _dynami } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2639,14 +2639,14 @@ struct miqt_array /* of QModelIndex* */ QSortFilterProxyModel_protectedbase_per } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qsplitter.cpp b/qt6/gen_qsplitter.cpp index 2ec22dcd51..15258c2736 100644 --- a/qt6/gen_qsplitter.cpp +++ b/qt6/gen_qsplitter.cpp @@ -1098,12 +1098,12 @@ QSize* QSplitter_minimumSizeHint(const QSplitter* self) { struct miqt_array /* of int */ QSplitter_sizes(const QSplitter* self) { QList _ret = self->sizes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qstandarditemmodel.cpp b/qt6/gen_qstandarditemmodel.cpp index 95b9ff0417..ccb7d336dc 100644 --- a/qt6/gen_qstandarditemmodel.cpp +++ b/qt6/gen_qstandarditemmodel.cpp @@ -559,7 +559,7 @@ void QStandardItem_setChild2(QStandardItem* self, int row, QStandardItem* item) } void QStandardItem_insertRow(QStandardItem* self, int row, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -569,7 +569,7 @@ void QStandardItem_insertRow(QStandardItem* self, int row, struct miqt_array /* } void QStandardItem_insertColumn(QStandardItem* self, int column, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -579,7 +579,7 @@ void QStandardItem_insertColumn(QStandardItem* self, int column, struct miqt_arr } void QStandardItem_insertRows(QStandardItem* self, int row, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -613,7 +613,7 @@ void QStandardItem_removeColumns(QStandardItem* self, int column, int count) { } void QStandardItem_appendRow(QStandardItem* self, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -623,7 +623,7 @@ void QStandardItem_appendRow(QStandardItem* self, struct miqt_array /* of QStand } void QStandardItem_appendRows(QStandardItem* self, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -633,7 +633,7 @@ void QStandardItem_appendRows(QStandardItem* self, struct miqt_array /* of QStan } void QStandardItem_appendColumn(QStandardItem* self, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -655,27 +655,27 @@ QStandardItem* QStandardItem_takeChild(QStandardItem* self, int row) { } struct miqt_array /* of QStandardItem* */ QStandardItem_takeRow(QStandardItem* self, int row) { - QList _ret = self->takeRow(static_cast(row)); + QList _ret = self->takeRow(static_cast(row)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QStandardItem* */ QStandardItem_takeColumn(QStandardItem* self, int column) { - QList _ret = self->takeColumn(static_cast(column)); + QList _ret = self->takeColumn(static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1281,13 +1281,13 @@ class MiqtVirtualQStandardItemModel final : public QStandardItemModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QStandardItemModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QStandardItemModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1303,19 +1303,19 @@ class MiqtVirtualQStandardItemModel final : public QStandardItemModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QStandardItemModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QStandardItemModel_mimeData(this, handle__mimeData, sigval1); @@ -1512,7 +1512,7 @@ class MiqtVirtualQStandardItemModel final : public QStandardItemModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QStandardItemModel::match(start, role, value, hits, flags); } @@ -1528,7 +1528,7 @@ class MiqtVirtualQStandardItemModel final : public QStandardItemModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QStandardItemModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1974,7 +1974,7 @@ void QStandardItemModel_setVerticalHeaderItem(QStandardItemModel* self, int row, } void QStandardItemModel_setHorizontalHeaderLabels(QStandardItemModel* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; + QList labels_QList; labels_QList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { @@ -1985,7 +1985,7 @@ void QStandardItemModel_setHorizontalHeaderLabels(QStandardItemModel* self, stru } void QStandardItemModel_setVerticalHeaderLabels(QStandardItemModel* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; + QList labels_QList; labels_QList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { @@ -2004,7 +2004,7 @@ void QStandardItemModel_setColumnCount(QStandardItemModel* self, int columns) { } void QStandardItemModel_appendRow(QStandardItemModel* self, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -2014,7 +2014,7 @@ void QStandardItemModel_appendRow(QStandardItemModel* self, struct miqt_array /* } void QStandardItemModel_appendColumn(QStandardItemModel* self, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -2028,7 +2028,7 @@ void QStandardItemModel_appendRowWithItem(QStandardItemModel* self, QStandardIte } void QStandardItemModel_insertRow(QStandardItemModel* self, int row, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -2038,7 +2038,7 @@ void QStandardItemModel_insertRow(QStandardItemModel* self, int row, struct miqt } void QStandardItemModel_insertColumn(QStandardItemModel* self, int column, struct miqt_array /* of QStandardItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QStandardItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -2064,27 +2064,27 @@ QStandardItem* QStandardItemModel_takeItem(QStandardItemModel* self, int row) { } struct miqt_array /* of QStandardItem* */ QStandardItemModel_takeRow(QStandardItemModel* self, int row) { - QList _ret = self->takeRow(static_cast(row)); + QList _ret = self->takeRow(static_cast(row)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QStandardItem* */ QStandardItemModel_takeColumn(QStandardItemModel* self, int column) { - QList _ret = self->takeColumn(static_cast(column)); + QList _ret = self->takeColumn(static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2107,14 +2107,14 @@ void QStandardItemModel_setItemPrototype(QStandardItemModel* self, QStandardItem struct miqt_array /* of QStandardItem* */ QStandardItemModel_findItems(const QStandardItemModel* self, struct miqt_string text) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->findItems(text_QString); + QList _ret = self->findItems(text_QString); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2128,10 +2128,10 @@ void QStandardItemModel_setSortRole(QStandardItemModel* self, int role) { } struct miqt_array /* of struct miqt_string */ QStandardItemModel_mimeTypes(const QStandardItemModel* self) { - QStringList _ret = self->mimeTypes(); + QList _ret = self->mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2142,13 +2142,13 @@ struct miqt_array /* of struct miqt_string */ QStandardItemModel_mimeTypes(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } QMimeData* QStandardItemModel_mimeData(const QStandardItemModel* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2212,28 +2212,28 @@ QStandardItem* QStandardItemModel_takeItem2(QStandardItemModel* self, int row, i struct miqt_array /* of QStandardItem* */ QStandardItemModel_findItems2(const QStandardItemModel* self, struct miqt_string text, int flags) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->findItems(text_QString, static_cast(flags)); + QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QStandardItem* */ QStandardItemModel_findItems3(const QStandardItemModel* self, struct miqt_string text, int flags, int column) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->findItems(text_QString, static_cast(flags), static_cast(column)); + QList _ret = self->findItems(text_QString, static_cast(flags), static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStandardItem** _arr = static_cast(malloc(sizeof(QStandardItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2584,10 +2584,10 @@ bool QStandardItemModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QStandardItemModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QStandardItemModel::mimeTypes(); + QList _ret = static_cast(self)->QStandardItemModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2598,7 +2598,7 @@ struct miqt_array /* of struct miqt_string */ QStandardItemModel_virtualbase_mi _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2614,7 +2614,7 @@ bool QStandardItemModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QStandardItemModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2761,14 +2761,14 @@ bool QStandardItemModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QStandardItemModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QStandardItemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QStandardItemModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2946,7 +2946,7 @@ void QStandardItemModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const v } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -3139,13 +3139,13 @@ void QStandardItemModel_protectedbase_changePersistentIndexList(bool* _dynamic_c } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -3162,14 +3162,14 @@ struct miqt_array /* of QModelIndex* */ QStandardItemModel_protectedbase_persis } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qstandardpaths.cpp b/qt6/gen_qstandardpaths.cpp index 3c5a432b7b..b081c71f2f 100644 --- a/qt6/gen_qstandardpaths.cpp +++ b/qt6/gen_qstandardpaths.cpp @@ -26,10 +26,10 @@ struct miqt_string QStandardPaths_writableLocation(int type) { } struct miqt_array /* of struct miqt_string */ QStandardPaths_standardLocations(int type) { - QStringList _ret = QStandardPaths::standardLocations(static_cast(type)); + QList _ret = QStandardPaths::standardLocations(static_cast(type)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -40,7 +40,7 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_standardLocations( _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -59,10 +59,10 @@ struct miqt_string QStandardPaths_locate(int type, struct miqt_string fileName) struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll(int type, struct miqt_string fileName) { QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - QStringList _ret = QStandardPaths::locateAll(static_cast(type), fileName_QString); + QList _ret = QStandardPaths::locateAll(static_cast(type), fileName_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -73,7 +73,7 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll(int type _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -123,10 +123,10 @@ struct miqt_string QStandardPaths_locate2(int type, struct miqt_string fileName, struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll2(int type, struct miqt_string fileName, int options) { QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - QStringList _ret = QStandardPaths::locateAll(static_cast(type), fileName_QString, static_cast(options)); + QList _ret = QStandardPaths::locateAll(static_cast(type), fileName_QString, static_cast(options)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -137,14 +137,14 @@ struct miqt_array /* of struct miqt_string */ QStandardPaths_locateAll2(int typ _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_string QStandardPaths_findExecutable2(struct miqt_string executableName, struct miqt_array /* of struct miqt_string */ paths) { QString executableName_QString = QString::fromUtf8(executableName.data, executableName.len); - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { diff --git a/qt6/gen_qstorageinfo.cpp b/qt6/gen_qstorageinfo.cpp index da69a1dde6..f33eec1199 100644 --- a/qt6/gen_qstorageinfo.cpp +++ b/qt6/gen_qstorageinfo.cpp @@ -148,12 +148,12 @@ void QStorageInfo_refresh(QStorageInfo* self) { struct miqt_array /* of QStorageInfo* */ QStorageInfo_mountedVolumes() { QList _ret = QStorageInfo::mountedVolumes(); // Convert QList<> from C++ memory to manually-managed C memory - QStorageInfo** _arr = static_cast(malloc(sizeof(QStorageInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QStorageInfo** _arr = static_cast(malloc(sizeof(QStorageInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QStorageInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qstringlistmodel.cpp b/qt6/gen_qstringlistmodel.cpp index a1e4ba0a07..888219046c 100644 --- a/qt6/gen_qstringlistmodel.cpp +++ b/qt6/gen_qstringlistmodel.cpp @@ -76,9 +76,9 @@ class MiqtVirtualQStringListModel final : public QStringListModel { public: MiqtVirtualQStringListModel(): QStringListModel() {} - MiqtVirtualQStringListModel(const QStringList& strings): QStringListModel(strings) {} + MiqtVirtualQStringListModel(const QList& strings): QStringListModel(strings) {} MiqtVirtualQStringListModel(QObject* parent): QStringListModel(parent) {} - MiqtVirtualQStringListModel(const QStringList& strings, QObject* parent): QStringListModel(strings, parent) {} + MiqtVirtualQStringListModel(const QList& strings, QObject* parent): QStringListModel(strings, parent) {} virtual ~MiqtVirtualQStringListModel() override = default; @@ -440,13 +440,13 @@ class MiqtVirtualQStringListModel final : public QStringListModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QStringListModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QStringListModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -462,19 +462,19 @@ class MiqtVirtualQStringListModel final : public QStringListModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QStringListModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QStringListModel_mimeData(this, handle__mimeData, sigval1); @@ -644,7 +644,7 @@ class MiqtVirtualQStringListModel final : public QStringListModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QStringListModel::match(start, role, value, hits, flags); } @@ -660,7 +660,7 @@ class MiqtVirtualQStringListModel final : public QStringListModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QStringListModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -933,7 +933,7 @@ QStringListModel* QStringListModel_new() { } QStringListModel* QStringListModel_new2(struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -948,7 +948,7 @@ QStringListModel* QStringListModel_new3(QObject* parent) { } QStringListModel* QStringListModel_new4(struct miqt_array /* of struct miqt_string */ strings, QObject* parent) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -1051,10 +1051,10 @@ void QStringListModel_sort(QStringListModel* self, int column, int order) { } struct miqt_array /* of struct miqt_string */ QStringListModel_stringList(const QStringListModel* self) { - QStringList _ret = self->stringList(); + QList _ret = self->stringList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1065,13 +1065,13 @@ struct miqt_array /* of struct miqt_string */ QStringListModel_stringList(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QStringListModel_setStringList(QStringListModel* self, struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -1379,10 +1379,10 @@ bool QStringListModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QStringListModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QStringListModel::mimeTypes(); + QList _ret = static_cast(self)->QStringListModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1393,7 +1393,7 @@ struct miqt_array /* of struct miqt_string */ QStringListModel_virtualbase_mime _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1409,7 +1409,7 @@ bool QStringListModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QStringListModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1542,14 +1542,14 @@ bool QStringListModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QStringListModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QStringListModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QStringListModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1774,7 +1774,7 @@ void QStringListModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const voi } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1967,13 +1967,13 @@ void QStringListModel_protectedbase_changePersistentIndexList(bool* _dynamic_cas } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -1990,14 +1990,14 @@ struct miqt_array /* of QModelIndex* */ QStringListModel_protectedbase_persiste } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qstringview.cpp b/qt6/gen_qstringview.cpp index 0c22a00819..418158aee2 100644 --- a/qt6/gen_qstringview.cpp +++ b/qt6/gen_qstringview.cpp @@ -80,14 +80,14 @@ struct miqt_string QStringView_toLocal8Bit(const QStringView* self) { } struct miqt_array /* of unsigned int */ QStringView_toUcs4(const QStringView* self) { - QList _ret = self->toUcs4(); + QList _ret = self->toUcs4(); // Convert QList<> from C++ memory to manually-managed C memory - unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + unsigned int* _arr = static_cast(malloc(sizeof(unsigned int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qstyleditemdelegate.cpp b/qt6/gen_qstyleditemdelegate.cpp index 488c8e3e4c..87fa5e439c 100644 --- a/qt6/gen_qstyleditemdelegate.cpp +++ b/qt6/gen_qstyleditemdelegate.cpp @@ -731,12 +731,12 @@ bool QStyledItemDelegate_override_virtual_paintingRoles(void* self, intptr_t slo struct miqt_array /* of int */ QStyledItemDelegate_virtualbase_paintingRoles(const void* self) { QList _ret = static_cast(self)->QStyledItemDelegate::paintingRoles(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qstylefactory.cpp b/qt6/gen_qstylefactory.cpp index 931e0d2c58..b3e20b51a0 100644 --- a/qt6/gen_qstylefactory.cpp +++ b/qt6/gen_qstylefactory.cpp @@ -16,10 +16,10 @@ extern "C" { #endif struct miqt_array /* of struct miqt_string */ QStyleFactory_keys() { - QStringList _ret = QStyleFactory::keys(); + QList _ret = QStyleFactory::keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -30,7 +30,7 @@ struct miqt_array /* of struct miqt_string */ QStyleFactory_keys() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtableview.cpp b/qt6/gen_qtableview.cpp index c8f21a612e..df885ed470 100644 --- a/qt6/gen_qtableview.cpp +++ b/qt6/gen_qtableview.cpp @@ -447,13 +447,13 @@ class MiqtVirtualQTableView final : public QTableView { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QTableView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTableView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -732,12 +732,12 @@ class MiqtVirtualQTableView final : public QTableView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTableView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -2271,14 +2271,14 @@ bool QTableView_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QTableView_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QTableView::selectedIndexes(); + QList _ret = static_cast(self)->QTableView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtablewidget.cpp b/qt6/gen_qtablewidget.cpp index e304111368..f360f97b00 100644 --- a/qt6/gen_qtablewidget.cpp +++ b/qt6/gen_qtablewidget.cpp @@ -680,13 +680,13 @@ class MiqtVirtualQTableWidget final : public QTableWidget { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QTableWidget::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QTableWidget_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -702,19 +702,19 @@ class MiqtVirtualQTableWidget final : public QTableWidget { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QList& items) const override { + virtual QMimeData* mimeData(const QList& items) const override { if (handle__mimeData == 0) { return QTableWidget::mimeData(items); } - const QList& items_ret = items; + const QList& items_ret = items; // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** items_arr = static_cast(malloc(sizeof(QTableWidgetItem*) * items_ret.length())); - for (size_t i = 0, e = items_ret.length(); i < e; ++i) { + QTableWidgetItem** items_arr = static_cast(malloc(sizeof(QTableWidgetItem*) * items_ret.size())); + for (size_t i = 0, e = items_ret.size(); i < e; ++i) { items_arr[i] = items_ret[i]; } struct miqt_array items_out; - items_out.len = items_ret.length(); + items_out.len = items_ret.size(); items_out.data = static_cast(items_arr); struct miqt_array /* of QTableWidgetItem* */ sigval1 = items_out; QMimeData* callback_return_value = miqt_exec_callback_QTableWidget_mimeData(this, handle__mimeData, sigval1); @@ -1045,13 +1045,13 @@ class MiqtVirtualQTableWidget final : public QTableWidget { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QTableWidget::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTableWidget_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1330,12 +1330,12 @@ class MiqtVirtualQTableWidget final : public QTableWidget { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTableWidget_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -2431,14 +2431,14 @@ QTableWidgetItem* QTableWidget_takeItem(QTableWidget* self, int row, int column) } struct miqt_array /* of QTableWidgetItem* */ QTableWidget_items(const QTableWidget* self, QMimeData* data) { - QList _ret = self->items(data); + QList _ret = self->items(data); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2476,7 +2476,7 @@ QTableWidgetItem* QTableWidget_takeHorizontalHeaderItem(QTableWidget* self, int } void QTableWidget_setVerticalHeaderLabels(QTableWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; + QList labels_QList; labels_QList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { @@ -2487,7 +2487,7 @@ void QTableWidget_setVerticalHeaderLabels(QTableWidget* self, struct miqt_array } void QTableWidget_setHorizontalHeaderLabels(QTableWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; + QList labels_QList; labels_QList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { @@ -2572,39 +2572,39 @@ void QTableWidget_setRangeSelected(QTableWidget* self, QTableWidgetSelectionRang struct miqt_array /* of QTableWidgetSelectionRange* */ QTableWidget_selectedRanges(const QTableWidget* self) { QList _ret = self->selectedRanges(); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetSelectionRange** _arr = static_cast(malloc(sizeof(QTableWidgetSelectionRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetSelectionRange** _arr = static_cast(malloc(sizeof(QTableWidgetSelectionRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTableWidgetSelectionRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QTableWidgetItem* */ QTableWidget_selectedItems(const QTableWidget* self) { - QList _ret = self->selectedItems(); + QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QTableWidgetItem* */ QTableWidget_findItems(const QTableWidget* self, struct miqt_string text, int flags) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->findItems(text_QString, static_cast(flags)); + QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTableWidgetItem** _arr = static_cast(malloc(sizeof(QTableWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2894,10 +2894,10 @@ bool QTableWidget_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QTableWidget_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QTableWidget::mimeTypes(); + QList _ret = static_cast(self)->QTableWidget::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -2908,7 +2908,7 @@ struct miqt_array /* of struct miqt_string */ QTableWidget_virtualbase_mimeType _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2924,7 +2924,7 @@ bool QTableWidget_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QTableWidget_virtualbase_mimeData(const void* self, struct miqt_array /* of QTableWidgetItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QTableWidgetItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -3197,14 +3197,14 @@ bool QTableWidget_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QTableWidget_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QTableWidget::selectedIndexes(); + QList _ret = static_cast(self)->QTableWidget::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextbrowser.cpp b/qt6/gen_qtextbrowser.cpp index 75428af05e..441050c32e 100644 --- a/qt6/gen_qtextbrowser.cpp +++ b/qt6/gen_qtextbrowser.cpp @@ -1236,10 +1236,10 @@ int QTextBrowser_sourceType(const QTextBrowser* self) { } struct miqt_array /* of struct miqt_string */ QTextBrowser_searchPaths(const QTextBrowser* self) { - QStringList _ret = self->searchPaths(); + QList _ret = self->searchPaths(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1250,13 +1250,13 @@ struct miqt_array /* of struct miqt_string */ QTextBrowser_searchPaths(const QT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QTextBrowser_setSearchPaths(QTextBrowser* self, struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { diff --git a/qt6/gen_qtextdocument.cpp b/qt6/gen_qtextdocument.cpp index 1fd8dfef5d..9ef4833ca5 100644 --- a/qt6/gen_qtextdocument.cpp +++ b/qt6/gen_qtextdocument.cpp @@ -561,12 +561,12 @@ void QTextDocument_addResource(QTextDocument* self, int type, QUrl* name, QVaria struct miqt_array /* of QTextFormat* */ QTextDocument_allFormats(const QTextDocument* self) { QList _ret = self->allFormats(); // Convert QList<> from C++ memory to manually-managed C memory - QTextFormat** _arr = static_cast(malloc(sizeof(QTextFormat*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextFormat** _arr = static_cast(malloc(sizeof(QTextFormat*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextFormat(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextdocumentwriter.cpp b/qt6/gen_qtextdocumentwriter.cpp index 381c5c224e..1d7e53949f 100644 --- a/qt6/gen_qtextdocumentwriter.cpp +++ b/qt6/gen_qtextdocumentwriter.cpp @@ -87,8 +87,8 @@ bool QTextDocumentWriter_writeWithFragment(QTextDocumentWriter* self, QTextDocum struct miqt_array /* of struct miqt_string */ QTextDocumentWriter_supportedDocumentFormats() { QList _ret = QTextDocumentWriter::supportedDocumentFormats(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -97,7 +97,7 @@ struct miqt_array /* of struct miqt_string */ QTextDocumentWriter_supportedDocu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextedit.cpp b/qt6/gen_qtextedit.cpp index 5a1ae8b552..de98ff0601 100644 --- a/qt6/gen_qtextedit.cpp +++ b/qt6/gen_qtextedit.cpp @@ -1457,12 +1457,12 @@ void QTextEdit_setExtraSelections(QTextEdit* self, struct miqt_array /* of QText struct miqt_array /* of QTextEdit__ExtraSelection* */ QTextEdit_extraSelections(const QTextEdit* self) { QList _ret = self->extraSelections(); // Convert QList<> from C++ memory to manually-managed C memory - QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextEdit__ExtraSelection** _arr = static_cast(malloc(sizeof(QTextEdit__ExtraSelection*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextEdit::ExtraSelection(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextformat.cpp b/qt6/gen_qtextformat.cpp index 96d5c310fb..077d8bf268 100644 --- a/qt6/gen_qtextformat.cpp +++ b/qt6/gen_qtextformat.cpp @@ -175,12 +175,12 @@ QTextLength* QTextFormat_lengthProperty(const QTextFormat* self, int propertyId) struct miqt_array /* of QTextLength* */ QTextFormat_lengthVectorProperty(const QTextFormat* self, int propertyId) { QList _ret = self->lengthVectorProperty(static_cast(propertyId)); // Convert QList<> from C++ memory to manually-managed C memory - QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLength(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -371,7 +371,7 @@ struct miqt_string QTextCharFormat_fontFamily(const QTextCharFormat* self) { } void QTextCharFormat_setFontFamilies(QTextCharFormat* self, struct miqt_array /* of struct miqt_string */ families) { - QStringList families_QList; + QList families_QList; families_QList.reserve(families.len); struct miqt_string* families_arr = static_cast(families.data); for(size_t i = 0; i < families.len; ++i) { @@ -632,7 +632,7 @@ struct miqt_string QTextCharFormat_anchorHref(const QTextCharFormat* self) { } void QTextCharFormat_setAnchorNames(QTextCharFormat* self, struct miqt_array /* of struct miqt_string */ names) { - QStringList names_QList; + QList names_QList; names_QList.reserve(names.len); struct miqt_string* names_arr = static_cast(names.data); for(size_t i = 0; i < names.len; ++i) { @@ -643,10 +643,10 @@ void QTextCharFormat_setAnchorNames(QTextCharFormat* self, struct miqt_array /* } struct miqt_array /* of struct miqt_string */ QTextCharFormat_anchorNames(const QTextCharFormat* self) { - QStringList _ret = self->anchorNames(); + QList _ret = self->anchorNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -657,7 +657,7 @@ struct miqt_array /* of struct miqt_string */ QTextCharFormat_anchorNames(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -824,12 +824,12 @@ void QTextBlockFormat_setTabPositions(QTextBlockFormat* self, struct miqt_array struct miqt_array /* of QTextOption__Tab* */ QTextBlockFormat_tabPositions(const QTextBlockFormat* self) { QList _ret = self->tabPositions(); // Convert QList<> from C++ memory to manually-managed C memory - QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextOption::Tab(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1153,12 +1153,12 @@ void QTextTableFormat_setColumnWidthConstraints(QTextTableFormat* self, struct m struct miqt_array /* of QTextLength* */ QTextTableFormat_columnWidthConstraints(const QTextTableFormat* self) { QList _ret = self->columnWidthConstraints(); // Convert QList<> from C++ memory to manually-managed C memory - QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLength** _arr = static_cast(malloc(sizeof(QTextLength*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLength(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextlayout.cpp b/qt6/gen_qtextlayout.cpp index f56c128d2f..c9ce1a003e 100644 --- a/qt6/gen_qtextlayout.cpp +++ b/qt6/gen_qtextlayout.cpp @@ -186,12 +186,12 @@ void QTextLayout_setFormats(QTextLayout* self, struct miqt_array /* of QTextLayo struct miqt_array /* of QTextLayout__FormatRange* */ QTextLayout_formats(const QTextLayout* self) { QList _ret = self->formats(); // Convert QList<> from C++ memory to manually-managed C memory - QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLayout::FormatRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -302,12 +302,12 @@ double QTextLayout_maximumWidth(const QTextLayout* self) { struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRuns(const QTextLayout* self) { QList _ret = self->glyphRuns(); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -347,12 +347,12 @@ void QTextLayout_draw3(const QTextLayout* self, QPainter* p, QPointF* pos, struc struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRunsWithFrom(const QTextLayout* self, int from) { QList _ret = self->glyphRuns(static_cast(from)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -360,12 +360,12 @@ struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRunsWithFrom(const QText struct miqt_array /* of QGlyphRun* */ QTextLayout_glyphRuns2(const QTextLayout* self, int from, int length) { QList _ret = self->glyphRuns(static_cast(from), static_cast(length)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -496,12 +496,12 @@ void QTextLine_draw(const QTextLine* self, QPainter* painter, QPointF* position) struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRuns(const QTextLine* self) { QList _ret = self->glyphRuns(); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -523,12 +523,12 @@ int QTextLine_xToCursor2(const QTextLine* self, double x, int param2) { struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRunsWithFrom(const QTextLine* self, int from) { QList _ret = self->glyphRuns(static_cast(from)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -536,12 +536,12 @@ struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRunsWithFrom(const QTextLi struct miqt_array /* of QGlyphRun* */ QTextLine_glyphRuns2(const QTextLine* self, int from, int length) { QList _ret = self->glyphRuns(static_cast(from), static_cast(length)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextlist.cpp b/qt6/gen_qtextlist.cpp index f0eea5888e..3f21874c8b 100644 --- a/qt6/gen_qtextlist.cpp +++ b/qt6/gen_qtextlist.cpp @@ -471,12 +471,12 @@ struct miqt_array /* of QTextBlock* */ QTextList_protectedbase_blockList(bool* *_dynamic_cast_ok = true; QList _ret = self_cast->blockList(); // Convert QList<> from C++ memory to manually-managed C memory - QTextBlock** _arr = static_cast(malloc(sizeof(QTextBlock*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextBlock** _arr = static_cast(malloc(sizeof(QTextBlock*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextBlock(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextobject.cpp b/qt6/gen_qtextobject.cpp index 7663729f93..4edced6947 100644 --- a/qt6/gen_qtextobject.cpp +++ b/qt6/gen_qtextobject.cpp @@ -356,14 +356,14 @@ void QTextFrame_setLayoutData(QTextFrame* self, QTextFrameLayoutData* data) { } struct miqt_array /* of QTextFrame* */ QTextFrame_childFrames(const QTextFrame* self) { - QList _ret = self->childFrames(); + QList _ret = self->childFrames(); // Convert QList<> from C++ memory to manually-managed C memory - QTextFrame** _arr = static_cast(malloc(sizeof(QTextFrame*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextFrame** _arr = static_cast(malloc(sizeof(QTextFrame*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -650,12 +650,12 @@ struct miqt_string QTextBlock_text(const QTextBlock* self) { struct miqt_array /* of QTextLayout__FormatRange* */ QTextBlock_textFormats(const QTextBlock* self) { QList _ret = self->textFormats(); // Convert QList<> from C++ memory to manually-managed C memory - QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextLayout__FormatRange** _arr = static_cast(malloc(sizeof(QTextLayout__FormatRange*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextLayout::FormatRange(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -802,12 +802,12 @@ struct miqt_string QTextFragment_text(const QTextFragment* self) { struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRuns(const QTextFragment* self) { QList _ret = self->glyphRuns(); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -815,12 +815,12 @@ struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRuns(const QTextFragme struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRunsWithFrom(const QTextFragment* self, int from) { QList _ret = self->glyphRuns(static_cast(from)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -828,12 +828,12 @@ struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRunsWithFrom(const QTe struct miqt_array /* of QGlyphRun* */ QTextFragment_glyphRuns2(const QTextFragment* self, int from, int length) { QList _ret = self->glyphRuns(static_cast(from), static_cast(length)); // Convert QList<> from C++ memory to manually-managed C memory - QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QGlyphRun** _arr = static_cast(malloc(sizeof(QGlyphRun*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QGlyphRun(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtextoption.cpp b/qt6/gen_qtextoption.cpp index b870b7e554..6a31b0baea 100644 --- a/qt6/gen_qtextoption.cpp +++ b/qt6/gen_qtextoption.cpp @@ -75,7 +75,7 @@ double QTextOption_tabStopDistance(const QTextOption* self) { } void QTextOption_setTabArray(QTextOption* self, struct miqt_array /* of double */ tabStops) { - QList tabStops_QList; + QList tabStops_QList; tabStops_QList.reserve(tabStops.len); double* tabStops_arr = static_cast(tabStops.data); for(size_t i = 0; i < tabStops.len; ++i) { @@ -85,14 +85,14 @@ void QTextOption_setTabArray(QTextOption* self, struct miqt_array /* of double * } struct miqt_array /* of double */ QTextOption_tabArray(const QTextOption* self) { - QList _ret = self->tabArray(); + QList _ret = self->tabArray(); // Convert QList<> from C++ memory to manually-managed C memory - double* _arr = static_cast(malloc(sizeof(double) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + double* _arr = static_cast(malloc(sizeof(double) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -110,12 +110,12 @@ void QTextOption_setTabs(QTextOption* self, struct miqt_array /* of QTextOption_ struct miqt_array /* of QTextOption__Tab* */ QTextOption_tabs(const QTextOption* self) { QList _ret = self->tabs(); // Convert QList<> from C++ memory to manually-managed C memory - QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTextOption__Tab** _arr = static_cast(malloc(sizeof(QTextOption__Tab*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTextOption::Tab(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtimezone.cpp b/qt6/gen_qtimezone.cpp index c19d9a6553..9e6acf2437 100644 --- a/qt6/gen_qtimezone.cpp +++ b/qt6/gen_qtimezone.cpp @@ -169,14 +169,14 @@ QTimeZone__OffsetData* QTimeZone_previousTransition(const QTimeZone* self, QDate } struct miqt_array /* of QTimeZone__OffsetData* */ QTimeZone_transitions(const QTimeZone* self, QDateTime* fromDateTime, QDateTime* toDateTime) { - QTimeZone::OffsetDataList _ret = self->transitions(*fromDateTime, *toDateTime); + QList _ret = self->transitions(*fromDateTime, *toDateTime); // Convert QList<> from C++ memory to manually-managed C memory - QTimeZone__OffsetData** _arr = static_cast(malloc(sizeof(QTimeZone__OffsetData*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTimeZone__OffsetData** _arr = static_cast(malloc(sizeof(QTimeZone__OffsetData*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QTimeZone::OffsetData(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -206,8 +206,8 @@ bool QTimeZone_isTimeZoneIdAvailable(struct miqt_string ianaId) { struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIds() { QList _ret = QTimeZone::availableTimeZoneIds(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -216,7 +216,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIds() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -224,8 +224,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIds() struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWithTerritory(unsigned short territory) { QList _ret = QTimeZone::availableTimeZoneIds(static_cast(territory)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -234,7 +234,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWit _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -242,8 +242,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWit struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWithOffsetSeconds(int offsetSeconds) { QList _ret = QTimeZone::availableTimeZoneIds(static_cast(offsetSeconds)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -252,7 +252,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_availableTimeZoneIdsWit _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -291,8 +291,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds(stru QByteArray windowsId_QByteArray(windowsId.data, windowsId.len); QList _ret = QTimeZone::windowsIdToIanaIds(windowsId_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -301,7 +301,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds(stru _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -310,8 +310,8 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds2(str QByteArray windowsId_QByteArray(windowsId.data, windowsId.len); QList _ret = QTimeZone::windowsIdToIanaIds(windowsId_QByteArray, static_cast(territory)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -320,7 +320,7 @@ struct miqt_array /* of struct miqt_string */ QTimeZone_windowsIdToIanaIds2(str _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtransposeproxymodel.cpp b/qt6/gen_qtransposeproxymodel.cpp index 08164f83e5..fd02d2550d 100644 --- a/qt6/gen_qtransposeproxymodel.cpp +++ b/qt6/gen_qtransposeproxymodel.cpp @@ -720,19 +720,19 @@ class MiqtVirtualQTransposeProxyModel final : public QTransposeProxyModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QTransposeProxyModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QTransposeProxyModel_mimeData(this, handle__mimeData, sigval1); @@ -791,13 +791,13 @@ class MiqtVirtualQTransposeProxyModel final : public QTransposeProxyModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QTransposeProxyModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QTransposeProxyModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -866,7 +866,7 @@ class MiqtVirtualQTransposeProxyModel final : public QTransposeProxyModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QTransposeProxyModel::match(start, role, value, hits, flags); } @@ -882,7 +882,7 @@ class MiqtVirtualQTransposeProxyModel final : public QTransposeProxyModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTransposeProxyModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1708,7 +1708,7 @@ bool QTransposeProxyModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QTransposeProxyModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1756,10 +1756,10 @@ bool QTransposeProxyModel_override_virtual_mimeTypes(void* self, intptr_t slot) } struct miqt_array /* of struct miqt_string */ QTransposeProxyModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QTransposeProxyModel::mimeTypes(); + QList _ret = static_cast(self)->QTransposeProxyModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1770,7 +1770,7 @@ struct miqt_array /* of struct miqt_string */ QTransposeProxyModel_virtualbase_ _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1849,14 +1849,14 @@ bool QTransposeProxyModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QTransposeProxyModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QTransposeProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QTransposeProxyModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2017,7 +2017,7 @@ void QTransposeProxyModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2210,13 +2210,13 @@ void QTransposeProxyModel_protectedbase_changePersistentIndexList(bool* _dynamic } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2233,14 +2233,14 @@ struct miqt_array /* of QModelIndex* */ QTransposeProxyModel_protectedbase_pers } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtreeview.cpp b/qt6/gen_qtreeview.cpp index 33193dac56..b52e65bb23 100644 --- a/qt6/gen_qtreeview.cpp +++ b/qt6/gen_qtreeview.cpp @@ -348,12 +348,12 @@ class MiqtVirtualQTreeView final : public QTreeView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTreeView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -547,13 +547,13 @@ class MiqtVirtualQTreeView final : public QTreeView { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QTreeView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTreeView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -2478,14 +2478,14 @@ bool QTreeView_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QTreeView_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QTreeView::selectedIndexes(); + QList _ret = static_cast(self)->QTreeView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qtreewidget.cpp b/qt6/gen_qtreewidget.cpp index 92a4cf1da7..00af206619 100644 --- a/qt6/gen_qtreewidget.cpp +++ b/qt6/gen_qtreewidget.cpp @@ -182,21 +182,21 @@ class MiqtVirtualQTreeWidgetItem final : public QTreeWidgetItem { public: MiqtVirtualQTreeWidgetItem(): QTreeWidgetItem() {} - MiqtVirtualQTreeWidgetItem(const QStringList& strings): QTreeWidgetItem(strings) {} + MiqtVirtualQTreeWidgetItem(const QList& strings): QTreeWidgetItem(strings) {} MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview): QTreeWidgetItem(treeview) {} - MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview, const QStringList& strings): QTreeWidgetItem(treeview, strings) {} + MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview, const QList& strings): QTreeWidgetItem(treeview, strings) {} MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview, QTreeWidgetItem* after): QTreeWidgetItem(treeview, after) {} MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent): QTreeWidgetItem(parent) {} - MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent, const QStringList& strings): QTreeWidgetItem(parent, strings) {} + MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent, const QList& strings): QTreeWidgetItem(parent, strings) {} MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent, QTreeWidgetItem* after): QTreeWidgetItem(parent, after) {} MiqtVirtualQTreeWidgetItem(const QTreeWidgetItem& other): QTreeWidgetItem(other) {} MiqtVirtualQTreeWidgetItem(int type): QTreeWidgetItem(type) {} - MiqtVirtualQTreeWidgetItem(const QStringList& strings, int type): QTreeWidgetItem(strings, type) {} + MiqtVirtualQTreeWidgetItem(const QList& strings, int type): QTreeWidgetItem(strings, type) {} MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview, int type): QTreeWidgetItem(treeview, type) {} - MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview, const QStringList& strings, int type): QTreeWidgetItem(treeview, strings, type) {} + MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview, const QList& strings, int type): QTreeWidgetItem(treeview, strings, type) {} MiqtVirtualQTreeWidgetItem(QTreeWidget* treeview, QTreeWidgetItem* after, int type): QTreeWidgetItem(treeview, after, type) {} MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent, int type): QTreeWidgetItem(parent, type) {} - MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent, const QStringList& strings, int type): QTreeWidgetItem(parent, strings, type) {} + MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent, const QList& strings, int type): QTreeWidgetItem(parent, strings, type) {} MiqtVirtualQTreeWidgetItem(QTreeWidgetItem* parent, QTreeWidgetItem* after, int type): QTreeWidgetItem(parent, after, type) {} virtual ~MiqtVirtualQTreeWidgetItem() override = default; @@ -319,7 +319,7 @@ QTreeWidgetItem* QTreeWidgetItem_new() { } QTreeWidgetItem* QTreeWidgetItem_new2(struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -334,7 +334,7 @@ QTreeWidgetItem* QTreeWidgetItem_new3(QTreeWidget* treeview) { } QTreeWidgetItem* QTreeWidgetItem_new4(QTreeWidget* treeview, struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -353,7 +353,7 @@ QTreeWidgetItem* QTreeWidgetItem_new6(QTreeWidgetItem* parent) { } QTreeWidgetItem* QTreeWidgetItem_new7(QTreeWidgetItem* parent, struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -376,7 +376,7 @@ QTreeWidgetItem* QTreeWidgetItem_new10(int type) { } QTreeWidgetItem* QTreeWidgetItem_new11(struct miqt_array /* of struct miqt_string */ strings, int type) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -391,7 +391,7 @@ QTreeWidgetItem* QTreeWidgetItem_new12(QTreeWidget* treeview, int type) { } QTreeWidgetItem* QTreeWidgetItem_new13(QTreeWidget* treeview, struct miqt_array /* of struct miqt_string */ strings, int type) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -410,7 +410,7 @@ QTreeWidgetItem* QTreeWidgetItem_new15(QTreeWidgetItem* parent, int type) { } QTreeWidgetItem* QTreeWidgetItem_new16(QTreeWidgetItem* parent, struct miqt_array /* of struct miqt_string */ strings, int type) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { @@ -680,7 +680,7 @@ QTreeWidgetItem* QTreeWidgetItem_takeChild(QTreeWidgetItem* self, int index) { } void QTreeWidgetItem_addChildren(QTreeWidgetItem* self, struct miqt_array /* of QTreeWidgetItem* */ children) { - QList children_QList; + QList children_QList; children_QList.reserve(children.len); QTreeWidgetItem** children_arr = static_cast(children.data); for(size_t i = 0; i < children.len; ++i) { @@ -690,7 +690,7 @@ void QTreeWidgetItem_addChildren(QTreeWidgetItem* self, struct miqt_array /* of } void QTreeWidgetItem_insertChildren(QTreeWidgetItem* self, int index, struct miqt_array /* of QTreeWidgetItem* */ children) { - QList children_QList; + QList children_QList; children_QList.reserve(children.len); QTreeWidgetItem** children_arr = static_cast(children.data); for(size_t i = 0; i < children.len; ++i) { @@ -700,14 +700,14 @@ void QTreeWidgetItem_insertChildren(QTreeWidgetItem* self, int index, struct miq } struct miqt_array /* of QTreeWidgetItem* */ QTreeWidgetItem_takeChildren(QTreeWidgetItem* self) { - QList _ret = self->takeChildren(); + QList _ret = self->takeChildren(); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -864,13 +864,13 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QTreeWidget::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QTreeWidget_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -886,19 +886,19 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QList& items) const override { + virtual QMimeData* mimeData(const QList& items) const override { if (handle__mimeData == 0) { return QTreeWidget::mimeData(items); } - const QList& items_ret = items; + const QList& items_ret = items; // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** items_arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * items_ret.length())); - for (size_t i = 0, e = items_ret.length(); i < e; ++i) { + QTreeWidgetItem** items_arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * items_ret.size())); + for (size_t i = 0, e = items_ret.size(); i < e; ++i) { items_arr[i] = items_ret[i]; } struct miqt_array items_out; - items_out.len = items_ret.length(); + items_out.len = items_ret.size(); items_out.data = static_cast(items_arr); struct miqt_array /* of QTreeWidgetItem* */ sigval1 = items_out; QMimeData* callback_return_value = miqt_exec_callback_QTreeWidget_mimeData(this, handle__mimeData, sigval1); @@ -1109,12 +1109,12 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QTreeWidget_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -1308,13 +1308,13 @@ class MiqtVirtualQTreeWidget final : public QTreeWidget { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QTreeWidget::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QTreeWidget_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -2638,7 +2638,7 @@ int QTreeWidget_indexOfTopLevelItem(const QTreeWidget* self, QTreeWidgetItem* it } void QTreeWidget_insertTopLevelItems(QTreeWidget* self, int index, struct miqt_array /* of QTreeWidgetItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QTreeWidgetItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -2648,7 +2648,7 @@ void QTreeWidget_insertTopLevelItems(QTreeWidget* self, int index, struct miqt_a } void QTreeWidget_addTopLevelItems(QTreeWidget* self, struct miqt_array /* of QTreeWidgetItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QTreeWidgetItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -2666,7 +2666,7 @@ void QTreeWidget_setHeaderItem(QTreeWidget* self, QTreeWidgetItem* item) { } void QTreeWidget_setHeaderLabels(QTreeWidget* self, struct miqt_array /* of struct miqt_string */ labels) { - QStringList labels_QList; + QList labels_QList; labels_QList.reserve(labels.len); struct miqt_string* labels_arr = static_cast(labels.data); for(size_t i = 0; i < labels.len; ++i) { @@ -2750,28 +2750,28 @@ void QTreeWidget_removeItemWidget(QTreeWidget* self, QTreeWidgetItem* item, int } struct miqt_array /* of QTreeWidgetItem* */ QTreeWidget_selectedItems(const QTreeWidget* self) { - QList _ret = self->selectedItems(); + QList _ret = self->selectedItems(); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QTreeWidgetItem* */ QTreeWidget_findItems(const QTreeWidget* self, struct miqt_string text, int flags) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->findItems(text_QString, static_cast(flags)); + QList _ret = self->findItems(text_QString, static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -2968,14 +2968,14 @@ bool QTreeWidget_isPersistentEditorOpen2(const QTreeWidget* self, QTreeWidgetIte struct miqt_array /* of QTreeWidgetItem* */ QTreeWidget_findItems2(const QTreeWidget* self, struct miqt_string text, int flags, int column) { QString text_QString = QString::fromUtf8(text.data, text.len); - QList _ret = self->findItems(text_QString, static_cast(flags), static_cast(column)); + QList _ret = self->findItems(text_QString, static_cast(flags), static_cast(column)); // Convert QList<> from C++ memory to manually-managed C memory - QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QTreeWidgetItem** _arr = static_cast(malloc(sizeof(QTreeWidgetItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3027,10 +3027,10 @@ bool QTreeWidget_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QTreeWidget_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QTreeWidget::mimeTypes(); + QList _ret = static_cast(self)->QTreeWidget::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -3041,7 +3041,7 @@ struct miqt_array /* of struct miqt_string */ QTreeWidget_virtualbase_mimeTypes _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -3057,7 +3057,7 @@ bool QTreeWidget_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QTreeWidget_virtualbase_mimeData(const void* self, struct miqt_array /* of QTreeWidgetItem* */ items) { - QList items_QList; + QList items_QList; items_QList.reserve(items.len); QTreeWidgetItem** items_arr = static_cast(items.data); for(size_t i = 0; i < items.len; ++i) { @@ -3379,14 +3379,14 @@ bool QTreeWidget_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QTreeWidget_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QTreeWidget::selectedIndexes(); + QList _ret = static_cast(self)->QTreeWidget::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qundogroup.cpp b/qt6/gen_qundogroup.cpp index 2534591ba8..a6a5c76ed0 100644 --- a/qt6/gen_qundogroup.cpp +++ b/qt6/gen_qundogroup.cpp @@ -213,14 +213,14 @@ void QUndoGroup_removeStack(QUndoGroup* self, QUndoStack* stack) { } struct miqt_array /* of QUndoStack* */ QUndoGroup_stacks(const QUndoGroup* self) { - QList _ret = self->stacks(); + QList _ret = self->stacks(); // Convert QList<> from C++ memory to manually-managed C memory - QUndoStack** _arr = static_cast(malloc(sizeof(QUndoStack*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUndoStack** _arr = static_cast(malloc(sizeof(QUndoStack*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qundoview.cpp b/qt6/gen_qundoview.cpp index 40270bae82..88d03a1fea 100644 --- a/qt6/gen_qundoview.cpp +++ b/qt6/gen_qundoview.cpp @@ -327,12 +327,12 @@ class MiqtVirtualQUndoView final : public QUndoView { QModelIndex* sigval2 = const_cast(&bottomRight_ret); const QList& roles_ret = roles; // Convert QList<> from C++ memory to manually-managed C memory - int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.length())); - for (size_t i = 0, e = roles_ret.length(); i < e; ++i) { + int* roles_arr = static_cast(malloc(sizeof(int) * roles_ret.size())); + for (size_t i = 0, e = roles_ret.size(); i < e; ++i) { roles_arr[i] = roles_ret[i]; } struct miqt_array roles_out; - roles_out.len = roles_ret.length(); + roles_out.len = roles_ret.size(); roles_out.data = static_cast(roles_arr); struct miqt_array /* of int */ sigval3 = roles_out; miqt_exec_callback_QUndoView_dataChanged(this, handle__dataChanged, sigval1, sigval2, sigval3); @@ -663,13 +663,13 @@ class MiqtVirtualQUndoView final : public QUndoView { intptr_t handle__selectedIndexes = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList selectedIndexes() const override { + virtual QList selectedIndexes() const override { if (handle__selectedIndexes == 0) { return QUndoView::selectedIndexes(); } struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QUndoView_selectedIndexes(this, handle__selectedIndexes); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -2299,14 +2299,14 @@ bool QUndoView_override_virtual_selectedIndexes(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QUndoView_virtualbase_selectedIndexes(const void* self) { - QModelIndexList _ret = static_cast(self)->QUndoView::selectedIndexes(); + QList _ret = static_cast(self)->QUndoView::selectedIndexes(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qurl.cpp b/qt6/gen_qurl.cpp index a3882a0c3e..b08dc57175 100644 --- a/qt6/gen_qurl.cpp +++ b/qt6/gen_qurl.cpp @@ -399,10 +399,10 @@ struct miqt_string QUrl_toAce(struct miqt_string domain) { } struct miqt_array /* of struct miqt_string */ QUrl_idnWhitelist() { - QStringList _ret = QUrl::idnWhitelist(); + QList _ret = QUrl::idnWhitelist(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -413,7 +413,7 @@ struct miqt_array /* of struct miqt_string */ QUrl_idnWhitelist() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -425,10 +425,10 @@ struct miqt_array /* of struct miqt_string */ QUrl_toStringList(struct miqt_arr for(size_t i = 0; i < uris.len; ++i) { uris_QList.push_back(*(uris_arr[i])); } - QStringList _ret = QUrl::toStringList(uris_QList); + QList _ret = QUrl::toStringList(uris_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -439,13 +439,13 @@ struct miqt_array /* of struct miqt_string */ QUrl_toStringList(struct miqt_arr _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QUrl* */ QUrl_fromStringList(struct miqt_array /* of struct miqt_string */ uris) { - QStringList uris_QList; + QList uris_QList; uris_QList.reserve(uris.len); struct miqt_string* uris_arr = static_cast(uris.data); for(size_t i = 0; i < uris.len; ++i) { @@ -454,18 +454,18 @@ struct miqt_array /* of QUrl* */ QUrl_fromStringList(struct miqt_array /* of st } QList _ret = QUrl::fromStringList(uris_QList); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QUrl_setIdnWhitelist(struct miqt_array /* of struct miqt_string */ idnWhitelist) { - QStringList idnWhitelist_QList; + QList idnWhitelist_QList; idnWhitelist_QList.reserve(idnWhitelist.len); struct miqt_string* idnWhitelist_arr = static_cast(idnWhitelist.data); for(size_t i = 0; i < idnWhitelist.len; ++i) { @@ -686,7 +686,7 @@ struct miqt_string QUrl_toAce2(struct miqt_string domain, unsigned int options) } struct miqt_array /* of QUrl* */ QUrl_fromStringList2(struct miqt_array /* of struct miqt_string */ uris, int mode) { - QStringList uris_QList; + QList uris_QList; uris_QList.reserve(uris.len); struct miqt_string* uris_arr = static_cast(uris.data); for(size_t i = 0; i < uris.len; ++i) { @@ -695,12 +695,12 @@ struct miqt_array /* of QUrl* */ QUrl_fromStringList2(struct miqt_array /* of s } QList _ret = QUrl::fromStringList(uris_QList, static_cast(mode)); // Convert QList<> from C++ memory to manually-managed C memory - QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QUrl** _arr = static_cast(malloc(sizeof(QUrl*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QUrl(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qurlquery.cpp b/qt6/gen_qurlquery.cpp index 5d8410ddf9..53fbd7947e 100644 --- a/qt6/gen_qurlquery.cpp +++ b/qt6/gen_qurlquery.cpp @@ -121,8 +121,8 @@ void QUrlQuery_setQueryItems(QUrlQuery* self, struct miqt_array /* of struct miq struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QUrlQuery_queryItems(const QUrlQuery* self) { QList> _ret = self->queryItems(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -150,7 +150,7 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -185,10 +185,10 @@ struct miqt_string QUrlQuery_queryItemValue(const QUrlQuery* self, struct miqt_s struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues(const QUrlQuery* self, struct miqt_string key) { QString key_QString = QString::fromUtf8(key.data, key.len); - QStringList _ret = self->allQueryItemValues(key_QString); + QList _ret = self->allQueryItemValues(key_QString); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -199,7 +199,7 @@ struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues(cons _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -234,8 +234,8 @@ struct miqt_string QUrlQuery_toStringWithEncoding(const QUrlQuery* self, unsigne struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QUrlQuery_queryItemsWithEncoding(const QUrlQuery* self, unsigned int encoding) { QList> _ret = self->queryItems(static_cast(encoding)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -263,7 +263,7 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -282,10 +282,10 @@ struct miqt_string QUrlQuery_queryItemValue2(const QUrlQuery* self, struct miqt_ struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues2(const QUrlQuery* self, struct miqt_string key, unsigned int encoding) { QString key_QString = QString::fromUtf8(key.data, key.len); - QStringList _ret = self->allQueryItemValues(key_QString, static_cast(encoding)); + QList _ret = self->allQueryItemValues(key_QString, static_cast(encoding)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -296,7 +296,7 @@ struct miqt_array /* of struct miqt_string */ QUrlQuery_allQueryItemValues2(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qvariant.cpp b/qt6/gen_qvariant.cpp index bf8b46d507..ecba4e2638 100644 --- a/qt6/gen_qvariant.cpp +++ b/qt6/gen_qvariant.cpp @@ -104,7 +104,7 @@ QVariant* QVariant_new14(struct miqt_string string) { } QVariant* QVariant_new15(struct miqt_array /* of struct miqt_string */ stringlist) { - QStringList stringlist_QList; + QList stringlist_QList; stringlist_QList.reserve(stringlist.len); struct miqt_string* stringlist_arr = static_cast(stringlist.data); for(size_t i = 0; i < stringlist.len; ++i) { @@ -372,10 +372,10 @@ struct miqt_string QVariant_toString(const QVariant* self) { } struct miqt_array /* of struct miqt_string */ QVariant_toStringList(const QVariant* self) { - QStringList _ret = self->toStringList(); + QList _ret = self->toStringList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -386,7 +386,7 @@ struct miqt_array /* of struct miqt_string */ QVariant_toStringList(const QVari _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -410,12 +410,12 @@ QDateTime* QVariant_toDateTime(const QVariant* self) { struct miqt_array /* of QVariant* */ QVariant_toList(const QVariant* self) { QList _ret = self->toList(); // Convert QList<> from C++ memory to manually-managed C memory - QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QVariant** _arr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QVariant(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qvariantanimation.cpp b/qt6/gen_qvariantanimation.cpp index 213a9ff54c..48451786fd 100644 --- a/qt6/gen_qvariantanimation.cpp +++ b/qt6/gen_qvariantanimation.cpp @@ -343,10 +343,10 @@ void QVariantAnimation_setKeyValueAt(QVariantAnimation* self, double step, QVari } struct miqt_array /* of struct miqt_map tuple of double and QVariant* */ QVariantAnimation_keyValues(const QVariantAnimation* self) { - QVariantAnimation::KeyValues _ret = self->keyValues(); + QList> _ret = self->keyValues(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of double and QVariant* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QVariant* */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of double and QVariant* */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of double and QVariant* */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory double* _lv_first_arr = static_cast(malloc(sizeof(double))); @@ -360,13 +360,13 @@ struct miqt_array /* of struct miqt_map tuple of double and QVariant* */ QVa _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QVariantAnimation_setKeyValues(QVariantAnimation* self, struct miqt_array /* of struct miqt_map tuple of double and QVariant* */ values) { - QVariantAnimation::KeyValues values_QList; + QList> values_QList; values_QList.reserve(values.len); struct miqt_map /* tuple of double and QVariant* */ * values_arr = static_cast(values.data); for(size_t i = 0; i < values.len; ++i) { diff --git a/qt6/gen_qversionnumber.cpp b/qt6/gen_qversionnumber.cpp index 8b101a9a08..1a562526d1 100644 --- a/qt6/gen_qversionnumber.cpp +++ b/qt6/gen_qversionnumber.cpp @@ -73,12 +73,12 @@ QVersionNumber* QVersionNumber_normalized(const QVersionNumber* self) { struct miqt_array /* of int */ QVersionNumber_segments(const QVersionNumber* self) { QList _ret = self->segments(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qwidget.cpp b/qt6/gen_qwidget.cpp index 0ed7772eea..54cb1bc5a7 100644 --- a/qt6/gen_qwidget.cpp +++ b/qt6/gen_qwidget.cpp @@ -1986,7 +1986,7 @@ void QWidget_addAction(QWidget* self, QAction* action) { } void QWidget_addActions(QWidget* self, struct miqt_array /* of QAction* */ actions) { - QList actions_QList; + QList actions_QList; actions_QList.reserve(actions.len); QAction** actions_arr = static_cast(actions.data); for(size_t i = 0; i < actions.len; ++i) { @@ -1996,7 +1996,7 @@ void QWidget_addActions(QWidget* self, struct miqt_array /* of QAction* */ acti } void QWidget_insertActions(QWidget* self, QAction* before, struct miqt_array /* of QAction* */ actions) { - QList actions_QList; + QList actions_QList; actions_QList.reserve(actions.len); QAction** actions_arr = static_cast(actions.data); for(size_t i = 0; i < actions.len; ++i) { @@ -2014,14 +2014,14 @@ void QWidget_removeAction(QWidget* self, QAction* action) { } struct miqt_array /* of QAction* */ QWidget_actions(const QWidget* self) { - QList _ret = self->actions(); + QList _ret = self->actions(); // Convert QList<> from C++ memory to manually-managed C memory - QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAction** _arr = static_cast(malloc(sizeof(QAction*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qwidgetaction.cpp b/qt6/gen_qwidgetaction.cpp index ed485b2c34..242056642d 100644 --- a/qt6/gen_qwidgetaction.cpp +++ b/qt6/gen_qwidgetaction.cpp @@ -400,14 +400,14 @@ struct miqt_array /* of QWidget* */ QWidgetAction_protectedbase_createdWidgets( } *_dynamic_cast_ok = true; - QList _ret = self_cast->createdWidgets(); + QList _ret = self_cast->createdWidgets(); // Convert QList<> from C++ memory to manually-managed C memory - QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWidget** _arr = static_cast(malloc(sizeof(QWidget*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qwizard.cpp b/qt6/gen_qwizard.cpp index 1be38fc89a..04327569b7 100644 --- a/qt6/gen_qwizard.cpp +++ b/qt6/gen_qwizard.cpp @@ -1183,12 +1183,12 @@ bool QWizard_hasVisitedPage(const QWizard* self, int id) { struct miqt_array /* of int */ QWizard_visitedIds(const QWizard* self) { QList _ret = self->visitedIds(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1196,12 +1196,12 @@ struct miqt_array /* of int */ QWizard_visitedIds(const QWizard* self) { struct miqt_array /* of int */ QWizard_pageIds(const QWizard* self) { QList _ret = self->pageIds(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/gen_qxmlstream.cpp b/qt6/gen_qxmlstream.cpp index 58986c736a..886e605ebc 100644 --- a/qt6/gen_qxmlstream.cpp +++ b/qt6/gen_qxmlstream.cpp @@ -310,14 +310,14 @@ struct miqt_string QXmlStreamReader_readElementText(QXmlStreamReader* self) { } struct miqt_array /* of QXmlStreamNamespaceDeclaration* */ QXmlStreamReader_namespaceDeclarations(const QXmlStreamReader* self) { - QXmlStreamNamespaceDeclarations _ret = self->namespaceDeclarations(); + QList _ret = self->namespaceDeclarations(); // Convert QList<> from C++ memory to manually-managed C memory - QXmlStreamNamespaceDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNamespaceDeclaration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QXmlStreamNamespaceDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNamespaceDeclaration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QXmlStreamNamespaceDeclaration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -327,7 +327,7 @@ void QXmlStreamReader_addExtraNamespaceDeclaration(QXmlStreamReader* self, QXmlS } void QXmlStreamReader_addExtraNamespaceDeclarations(QXmlStreamReader* self, struct miqt_array /* of QXmlStreamNamespaceDeclaration* */ extraNamespaceDeclaractions) { - QXmlStreamNamespaceDeclarations extraNamespaceDeclaractions_QList; + QList extraNamespaceDeclaractions_QList; extraNamespaceDeclaractions_QList.reserve(extraNamespaceDeclaractions.len); QXmlStreamNamespaceDeclaration** extraNamespaceDeclaractions_arr = static_cast(extraNamespaceDeclaractions.data); for(size_t i = 0; i < extraNamespaceDeclaractions.len; ++i) { @@ -337,27 +337,27 @@ void QXmlStreamReader_addExtraNamespaceDeclarations(QXmlStreamReader* self, stru } struct miqt_array /* of QXmlStreamNotationDeclaration* */ QXmlStreamReader_notationDeclarations(const QXmlStreamReader* self) { - QXmlStreamNotationDeclarations _ret = self->notationDeclarations(); + QList _ret = self->notationDeclarations(); // Convert QList<> from C++ memory to manually-managed C memory - QXmlStreamNotationDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNotationDeclaration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QXmlStreamNotationDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamNotationDeclaration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QXmlStreamNotationDeclaration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of QXmlStreamEntityDeclaration* */ QXmlStreamReader_entityDeclarations(const QXmlStreamReader* self) { - QXmlStreamEntityDeclarations _ret = self->entityDeclarations(); + QList _ret = self->entityDeclarations(); // Convert QList<> from C++ memory to manually-managed C memory - QXmlStreamEntityDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamEntityDeclaration*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QXmlStreamEntityDeclaration** _arr = static_cast(malloc(sizeof(QXmlStreamEntityDeclaration*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QXmlStreamEntityDeclaration(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qaudiodevice.cpp b/qt6/multimedia/gen_qaudiodevice.cpp index 4308981acd..a00560aa71 100644 --- a/qt6/multimedia/gen_qaudiodevice.cpp +++ b/qt6/multimedia/gen_qaudiodevice.cpp @@ -100,13 +100,13 @@ int QAudioDevice_maximumChannelCount(const QAudioDevice* self) { struct miqt_array /* of uint16_t */ QAudioDevice_supportedSampleFormats(const QAudioDevice* self) { QList _ret = self->supportedSampleFormats(); // Convert QList<> from C++ memory to manually-managed C memory - uint16_t* _arr = static_cast(malloc(sizeof(uint16_t) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + uint16_t* _arr = static_cast(malloc(sizeof(uint16_t) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QAudioFormat::SampleFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qcameradevice.cpp b/qt6/multimedia/gen_qcameradevice.cpp index b922b69f57..7ade9ba6d8 100644 --- a/qt6/multimedia/gen_qcameradevice.cpp +++ b/qt6/multimedia/gen_qcameradevice.cpp @@ -118,12 +118,12 @@ int QCameraDevice_position(const QCameraDevice* self) { struct miqt_array /* of QSize* */ QCameraDevice_photoResolutions(const QCameraDevice* self) { QList _ret = self->photoResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSize** _arr = static_cast(malloc(sizeof(QSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -131,12 +131,12 @@ struct miqt_array /* of QSize* */ QCameraDevice_photoResolutions(const QCameraD struct miqt_array /* of QCameraFormat* */ QCameraDevice_videoFormats(const QCameraDevice* self) { QList _ret = self->videoFormats(); // Convert QList<> from C++ memory to manually-managed C memory - QCameraFormat** _arr = static_cast(malloc(sizeof(QCameraFormat*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraFormat** _arr = static_cast(malloc(sizeof(QCameraFormat*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraFormat(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qimagecapture.cpp b/qt6/multimedia/gen_qimagecapture.cpp index 2a59f31745..2e1b1dc56e 100644 --- a/qt6/multimedia/gen_qimagecapture.cpp +++ b/qt6/multimedia/gen_qimagecapture.cpp @@ -252,13 +252,13 @@ void QImageCapture_setFileFormat(QImageCapture* self, int format) { struct miqt_array /* of int */ QImageCapture_supportedFormats() { QList _ret = QImageCapture::supportedFormats(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QImageCapture::FileFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qmediadevices.cpp b/qt6/multimedia/gen_qmediadevices.cpp index 6013596f0d..d07d2a802f 100644 --- a/qt6/multimedia/gen_qmediadevices.cpp +++ b/qt6/multimedia/gen_qmediadevices.cpp @@ -203,12 +203,12 @@ struct miqt_string QMediaDevices_tr(const char* s) { struct miqt_array /* of QAudioDevice* */ QMediaDevices_audioInputs() { QList _ret = QMediaDevices::audioInputs(); // Convert QList<> from C++ memory to manually-managed C memory - QAudioDevice** _arr = static_cast(malloc(sizeof(QAudioDevice*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAudioDevice** _arr = static_cast(malloc(sizeof(QAudioDevice*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QAudioDevice(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -216,12 +216,12 @@ struct miqt_array /* of QAudioDevice* */ QMediaDevices_audioInputs() { struct miqt_array /* of QAudioDevice* */ QMediaDevices_audioOutputs() { QList _ret = QMediaDevices::audioOutputs(); // Convert QList<> from C++ memory to manually-managed C memory - QAudioDevice** _arr = static_cast(malloc(sizeof(QAudioDevice*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QAudioDevice** _arr = static_cast(malloc(sizeof(QAudioDevice*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QAudioDevice(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -229,12 +229,12 @@ struct miqt_array /* of QAudioDevice* */ QMediaDevices_audioOutputs() { struct miqt_array /* of QCameraDevice* */ QMediaDevices_videoInputs() { QList _ret = QMediaDevices::videoInputs(); // Convert QList<> from C++ memory to manually-managed C memory - QCameraDevice** _arr = static_cast(malloc(sizeof(QCameraDevice*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QCameraDevice** _arr = static_cast(malloc(sizeof(QCameraDevice*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QCameraDevice(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qmediaformat.cpp b/qt6/multimedia/gen_qmediaformat.cpp index da41c74cd5..51e73adc15 100644 --- a/qt6/multimedia/gen_qmediaformat.cpp +++ b/qt6/multimedia/gen_qmediaformat.cpp @@ -73,13 +73,13 @@ QMimeType* QMediaFormat_mimeType(const QMediaFormat* self) { struct miqt_array /* of int */ QMediaFormat_supportedFileFormats(QMediaFormat* self, int m) { QList _ret = self->supportedFileFormats(static_cast(m)); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QMediaFormat::FileFormat _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -87,13 +87,13 @@ struct miqt_array /* of int */ QMediaFormat_supportedFileFormats(QMediaFormat* struct miqt_array /* of int */ QMediaFormat_supportedVideoCodecs(QMediaFormat* self, int m) { QList _ret = self->supportedVideoCodecs(static_cast(m)); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QMediaFormat::VideoCodec _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -101,13 +101,13 @@ struct miqt_array /* of int */ QMediaFormat_supportedVideoCodecs(QMediaFormat* struct miqt_array /* of int */ QMediaFormat_supportedAudioCodecs(QMediaFormat* self, int m) { QList _ret = self->supportedAudioCodecs(static_cast(m)); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QMediaFormat::AudioCodec _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qmediametadata.cpp b/qt6/multimedia/gen_qmediametadata.cpp index 7ecaa9f3e9..38b1363732 100644 --- a/qt6/multimedia/gen_qmediametadata.cpp +++ b/qt6/multimedia/gen_qmediametadata.cpp @@ -38,13 +38,13 @@ void QMediaMetaData_remove(QMediaMetaData* self, int k) { struct miqt_array /* of int */ QMediaMetaData_keys(const QMediaMetaData* self) { QList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QMediaMetaData::Key _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qmediaplayer.cpp b/qt6/multimedia/gen_qmediaplayer.cpp index 9bf2eb5bbe..c0ad6dccf5 100644 --- a/qt6/multimedia/gen_qmediaplayer.cpp +++ b/qt6/multimedia/gen_qmediaplayer.cpp @@ -222,12 +222,12 @@ struct miqt_string QMediaPlayer_tr(const char* s) { struct miqt_array /* of QMediaMetaData* */ QMediaPlayer_audioTracks(const QMediaPlayer* self) { QList _ret = self->audioTracks(); // Convert QList<> from C++ memory to manually-managed C memory - QMediaMetaData** _arr = static_cast(malloc(sizeof(QMediaMetaData*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMediaMetaData** _arr = static_cast(malloc(sizeof(QMediaMetaData*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMediaMetaData(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -235,12 +235,12 @@ struct miqt_array /* of QMediaMetaData* */ QMediaPlayer_audioTracks(const QMedi struct miqt_array /* of QMediaMetaData* */ QMediaPlayer_videoTracks(const QMediaPlayer* self) { QList _ret = self->videoTracks(); // Convert QList<> from C++ memory to manually-managed C memory - QMediaMetaData** _arr = static_cast(malloc(sizeof(QMediaMetaData*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMediaMetaData** _arr = static_cast(malloc(sizeof(QMediaMetaData*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMediaMetaData(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -248,12 +248,12 @@ struct miqt_array /* of QMediaMetaData* */ QMediaPlayer_videoTracks(const QMedi struct miqt_array /* of QMediaMetaData* */ QMediaPlayer_subtitleTracks(const QMediaPlayer* self) { QList _ret = self->subtitleTracks(); // Convert QList<> from C++ memory to manually-managed C memory - QMediaMetaData** _arr = static_cast(malloc(sizeof(QMediaMetaData*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMediaMetaData** _arr = static_cast(malloc(sizeof(QMediaMetaData*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMediaMetaData(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qmediatimerange.cpp b/qt6/multimedia/gen_qmediatimerange.cpp index a11a4f5edb..1c9c450180 100644 --- a/qt6/multimedia/gen_qmediatimerange.cpp +++ b/qt6/multimedia/gen_qmediatimerange.cpp @@ -57,12 +57,12 @@ long long QMediaTimeRange_latestTime(const QMediaTimeRange* self) { struct miqt_array /* of QMediaTimeRange__Interval* */ QMediaTimeRange_intervals(const QMediaTimeRange* self) { QList _ret = self->intervals(); // Convert QList<> from C++ memory to manually-managed C memory - QMediaTimeRange__Interval** _arr = static_cast(malloc(sizeof(QMediaTimeRange__Interval*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QMediaTimeRange__Interval** _arr = static_cast(malloc(sizeof(QMediaTimeRange__Interval*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QMediaTimeRange::Interval(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/multimedia/gen_qsoundeffect.cpp b/qt6/multimedia/gen_qsoundeffect.cpp index b6293e6f37..4bc92016a2 100644 --- a/qt6/multimedia/gen_qsoundeffect.cpp +++ b/qt6/multimedia/gen_qsoundeffect.cpp @@ -217,10 +217,10 @@ struct miqt_string QSoundEffect_tr(const char* s) { } struct miqt_array /* of struct miqt_string */ QSoundEffect_supportedMimeTypes() { - QStringList _ret = QSoundEffect::supportedMimeTypes(); + QList _ret = QSoundEffect::supportedMimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -231,7 +231,7 @@ struct miqt_array /* of struct miqt_string */ QSoundEffect_supportedMimeTypes() _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/dtls/gen_qdtls.cpp b/qt6/network/dtls/gen_qdtls.cpp index 46b7023b02..5e3123cccb 100644 --- a/qt6/network/dtls/gen_qdtls.cpp +++ b/qt6/network/dtls/gen_qdtls.cpp @@ -719,12 +719,12 @@ struct miqt_string QDtls_dtlsErrorString(const QDtls* self) { struct miqt_array /* of QSslError* */ QDtls_peerVerificationErrors(const QDtls* self) { QList _ret = self->peerVerificationErrors(); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qabstractnetworkcache.cpp b/qt6/network/gen_qabstractnetworkcache.cpp index 04fee0e45c..0898a9a368 100644 --- a/qt6/network/gen_qabstractnetworkcache.cpp +++ b/qt6/network/gen_qabstractnetworkcache.cpp @@ -62,10 +62,10 @@ void QNetworkCacheMetaData_setUrl(QNetworkCacheMetaData* self, QUrl* url) { } struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QNetworkCacheMetaData_rawHeaders(const QNetworkCacheMetaData* self) { - QNetworkCacheMetaData::RawHeaderList _ret = self->rawHeaders(); + QList> _ret = self->rawHeaders(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -89,13 +89,13 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QNetworkCacheMetaData_setRawHeaders(QNetworkCacheMetaData* self, struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ headers) { - QNetworkCacheMetaData::RawHeaderList headers_QList; + QList> headers_QList; headers_QList.reserve(headers.len); struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * headers_arr = static_cast(headers.data); for(size_t i = 0; i < headers.len; ++i) { @@ -136,7 +136,7 @@ void QNetworkCacheMetaData_setSaveToDisk(QNetworkCacheMetaData* self, bool allow } struct miqt_map /* of int to QVariant* */ QNetworkCacheMetaData_attributes(const QNetworkCacheMetaData* self) { - QNetworkCacheMetaData::AttributesMap _ret = self->attributes(); + QHash _ret = self->attributes(); // Convert QMap<> from C++ memory to manually-managed C memory int* _karr = static_cast(malloc(sizeof(int) * _ret.size())); QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); @@ -155,7 +155,7 @@ struct miqt_map /* of int to QVariant* */ QNetworkCacheMetaData_attributes(cons } void QNetworkCacheMetaData_setAttributes(QNetworkCacheMetaData* self, struct miqt_map /* of int to QVariant* */ attributes) { - QNetworkCacheMetaData::AttributesMap attributes_QMap; + QHash attributes_QMap; attributes_QMap.reserve(attributes.len); int* attributes_karr = static_cast(attributes.keys); QVariant** attributes_varr = static_cast(attributes.values); diff --git a/qt6/network/gen_qauthenticator.cpp b/qt6/network/gen_qauthenticator.cpp index fac608e979..91adbe4801 100644 --- a/qt6/network/gen_qauthenticator.cpp +++ b/qt6/network/gen_qauthenticator.cpp @@ -89,7 +89,7 @@ QVariant* QAuthenticator_option(const QAuthenticator* self, struct miqt_string o } struct miqt_map /* of struct miqt_string to QVariant* */ QAuthenticator_options(const QAuthenticator* self) { - QVariantHash _ret = self->options(); + QHash _ret = self->options(); // Convert QMap<> from C++ memory to manually-managed C memory struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); QVariant** _varr = static_cast(malloc(sizeof(QVariant*) * _ret.size())); diff --git a/qt6/network/gen_qdnslookup.cpp b/qt6/network/gen_qdnslookup.cpp index 1c0ed070b4..206a842555 100644 --- a/qt6/network/gen_qdnslookup.cpp +++ b/qt6/network/gen_qdnslookup.cpp @@ -274,8 +274,8 @@ unsigned int QDnsTextRecord_timeToLive(const QDnsTextRecord* self) { struct miqt_array /* of struct miqt_string */ QDnsTextRecord_values(const QDnsTextRecord* self) { QList _ret = self->values(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -284,7 +284,7 @@ struct miqt_array /* of struct miqt_string */ QDnsTextRecord_values(const QDnsT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -541,12 +541,12 @@ void QDnsLookup_setNameserver(QDnsLookup* self, QHostAddress* nameserver) { struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_canonicalNameRecords(const QDnsLookup* self) { QList _ret = self->canonicalNameRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsDomainNameRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -554,12 +554,12 @@ struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_canonicalNameRecord struct miqt_array /* of QDnsHostAddressRecord* */ QDnsLookup_hostAddressRecords(const QDnsLookup* self) { QList _ret = self->hostAddressRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsHostAddressRecord** _arr = static_cast(malloc(sizeof(QDnsHostAddressRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsHostAddressRecord** _arr = static_cast(malloc(sizeof(QDnsHostAddressRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsHostAddressRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -567,12 +567,12 @@ struct miqt_array /* of QDnsHostAddressRecord* */ QDnsLookup_hostAddressRecords struct miqt_array /* of QDnsMailExchangeRecord* */ QDnsLookup_mailExchangeRecords(const QDnsLookup* self) { QList _ret = self->mailExchangeRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsMailExchangeRecord** _arr = static_cast(malloc(sizeof(QDnsMailExchangeRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsMailExchangeRecord** _arr = static_cast(malloc(sizeof(QDnsMailExchangeRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsMailExchangeRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -580,12 +580,12 @@ struct miqt_array /* of QDnsMailExchangeRecord* */ QDnsLookup_mailExchangeRecor struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_nameServerRecords(const QDnsLookup* self) { QList _ret = self->nameServerRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsDomainNameRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -593,12 +593,12 @@ struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_nameServerRecords(c struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_pointerRecords(const QDnsLookup* self) { QList _ret = self->pointerRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsDomainNameRecord** _arr = static_cast(malloc(sizeof(QDnsDomainNameRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsDomainNameRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -606,12 +606,12 @@ struct miqt_array /* of QDnsDomainNameRecord* */ QDnsLookup_pointerRecords(cons struct miqt_array /* of QDnsServiceRecord* */ QDnsLookup_serviceRecords(const QDnsLookup* self) { QList _ret = self->serviceRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsServiceRecord** _arr = static_cast(malloc(sizeof(QDnsServiceRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsServiceRecord** _arr = static_cast(malloc(sizeof(QDnsServiceRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsServiceRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -619,12 +619,12 @@ struct miqt_array /* of QDnsServiceRecord* */ QDnsLookup_serviceRecords(const Q struct miqt_array /* of QDnsTextRecord* */ QDnsLookup_textRecords(const QDnsLookup* self) { QList _ret = self->textRecords(); // Convert QList<> from C++ memory to manually-managed C memory - QDnsTextRecord** _arr = static_cast(malloc(sizeof(QDnsTextRecord*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QDnsTextRecord** _arr = static_cast(malloc(sizeof(QDnsTextRecord*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QDnsTextRecord(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qhostinfo.cpp b/qt6/network/gen_qhostinfo.cpp index bfd0930ea5..9ce52b320d 100644 --- a/qt6/network/gen_qhostinfo.cpp +++ b/qt6/network/gen_qhostinfo.cpp @@ -54,12 +54,12 @@ void QHostInfo_setHostName(QHostInfo* self, struct miqt_string name) { struct miqt_array /* of QHostAddress* */ QHostInfo_addresses(const QHostInfo* self) { QList _ret = self->addresses(); // Convert QList<> from C++ memory to manually-managed C memory - QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QHostAddress(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qnetworkaccessmanager.cpp b/qt6/network/gen_qnetworkaccessmanager.cpp index a1606f3963..3e3568825b 100644 --- a/qt6/network/gen_qnetworkaccessmanager.cpp +++ b/qt6/network/gen_qnetworkaccessmanager.cpp @@ -61,13 +61,13 @@ class MiqtVirtualQNetworkAccessManager final : public QNetworkAccessManager { intptr_t handle__supportedSchemes = 0; // Subclass to allow providing a Go implementation - virtual QStringList supportedSchemes() const override { + virtual QList supportedSchemes() const override { if (handle__supportedSchemes == 0) { return QNetworkAccessManager::supportedSchemes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QNetworkAccessManager_supportedSchemes(this, handle__supportedSchemes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -262,10 +262,10 @@ struct miqt_string QNetworkAccessManager_tr(const char* s) { } struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_supportedSchemes(const QNetworkAccessManager* self) { - QStringList _ret = self->supportedSchemes(); + QList _ret = self->supportedSchemes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -276,7 +276,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_supportedSc _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -350,12 +350,12 @@ void QNetworkAccessManager_addStrictTransportSecurityHosts(QNetworkAccessManager struct miqt_array /* of QHstsPolicy* */ QNetworkAccessManager_strictTransportSecurityHosts(const QNetworkAccessManager* self) { QList _ret = self->strictTransportSecurityHosts(); // Convert QList<> from C++ memory to manually-managed C memory - QHstsPolicy** _arr = static_cast(malloc(sizeof(QHstsPolicy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QHstsPolicy** _arr = static_cast(malloc(sizeof(QHstsPolicy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QHstsPolicy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -518,12 +518,12 @@ void QNetworkAccessManager_connect_sslErrors(QNetworkAccessManager* self, intptr QNetworkReply* sigval1 = reply; const QList& errors_ret = errors; // Convert QList<> from C++ memory to manually-managed C memory - QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.size())); + for (size_t i = 0, e = errors_ret.size(); i < e; ++i) { errors_arr[i] = new QSslError(errors_ret[i]); } struct miqt_array errors_out; - errors_out.len = errors_ret.length(); + errors_out.len = errors_ret.size(); errors_out.data = static_cast(errors_arr); struct miqt_array /* of QSslError* */ sigval2 = errors_out; miqt_exec_callback_QNetworkAccessManager_sslErrors(slot, sigval1, sigval2); @@ -604,10 +604,10 @@ bool QNetworkAccessManager_override_virtual_supportedSchemes(void* self, intptr_ } struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_virtualbase_supportedSchemes(const void* self) { - QStringList _ret = static_cast(self)->QNetworkAccessManager::supportedSchemes(); + QList _ret = static_cast(self)->QNetworkAccessManager::supportedSchemes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -618,7 +618,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_virtualbase _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -743,10 +743,10 @@ struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_protectedba } *_dynamic_cast_ok = true; - QStringList _ret = self_cast->supportedSchemesImplementation(); + QList _ret = self_cast->supportedSchemesImplementation(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -757,7 +757,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkAccessManager_protectedba _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qnetworkcookie.cpp b/qt6/network/gen_qnetworkcookie.cpp index cd378fdaab..99f0d9f23e 100644 --- a/qt6/network/gen_qnetworkcookie.cpp +++ b/qt6/network/gen_qnetworkcookie.cpp @@ -170,12 +170,12 @@ struct miqt_array /* of QNetworkCookie* */ QNetworkCookie_parseCookies(struct m QByteArray cookieString_QByteArray(cookieString.data, cookieString.len); QList _ret = QNetworkCookie::parseCookies(cookieString_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qnetworkcookiejar.cpp b/qt6/network/gen_qnetworkcookiejar.cpp index f017f583d1..9e63379e4e 100644 --- a/qt6/network/gen_qnetworkcookiejar.cpp +++ b/qt6/network/gen_qnetworkcookiejar.cpp @@ -78,12 +78,12 @@ class MiqtVirtualQNetworkCookieJar final : public QNetworkCookieJar { const QList& cookieList_ret = cookieList; // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** cookieList_arr = static_cast(malloc(sizeof(QNetworkCookie*) * cookieList_ret.length())); - for (size_t i = 0, e = cookieList_ret.length(); i < e; ++i) { + QNetworkCookie** cookieList_arr = static_cast(malloc(sizeof(QNetworkCookie*) * cookieList_ret.size())); + for (size_t i = 0, e = cookieList_ret.size(); i < e; ++i) { cookieList_arr[i] = new QNetworkCookie(cookieList_ret[i]); } struct miqt_array cookieList_out; - cookieList_out.len = cookieList_ret.length(); + cookieList_out.len = cookieList_ret.size(); cookieList_out.data = static_cast(cookieList_arr); struct miqt_array /* of QNetworkCookie* */ sigval1 = cookieList_out; const QUrl& url_ret = url; @@ -335,12 +335,12 @@ struct miqt_string QNetworkCookieJar_tr(const char* s) { struct miqt_array /* of QNetworkCookie* */ QNetworkCookieJar_cookiesForUrl(const QNetworkCookieJar* self, QUrl* url) { QList _ret = self->cookiesForUrl(*url); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -402,12 +402,12 @@ bool QNetworkCookieJar_override_virtual_cookiesForUrl(void* self, intptr_t slot) struct miqt_array /* of QNetworkCookie* */ QNetworkCookieJar_virtualbase_cookiesForUrl(const void* self, QUrl* url) { QList _ret = static_cast(self)->QNetworkCookieJar::cookiesForUrl(*url); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -596,12 +596,12 @@ struct miqt_array /* of QNetworkCookie* */ QNetworkCookieJar_protectedbase_allC *_dynamic_cast_ok = true; QList _ret = self_cast->allCookies(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkCookie** _arr = static_cast(malloc(sizeof(QNetworkCookie*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkCookie(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qnetworkinformation.cpp b/qt6/network/gen_qnetworkinformation.cpp index 39a99290f8..4c8cd094f9 100644 --- a/qt6/network/gen_qnetworkinformation.cpp +++ b/qt6/network/gen_qnetworkinformation.cpp @@ -95,10 +95,10 @@ bool QNetworkInformation_loadWithFeatures(int features) { } struct miqt_array /* of struct miqt_string */ QNetworkInformation_availableBackends() { - QStringList _ret = QNetworkInformation::availableBackends(); + QList _ret = QNetworkInformation::availableBackends(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -109,7 +109,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkInformation_availableBack _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qnetworkinterface.cpp b/qt6/network/gen_qnetworkinterface.cpp index 422ae01a5f..ae62a59342 100644 --- a/qt6/network/gen_qnetworkinterface.cpp +++ b/qt6/network/gen_qnetworkinterface.cpp @@ -188,12 +188,12 @@ struct miqt_string QNetworkInterface_hardwareAddress(const QNetworkInterface* se struct miqt_array /* of QNetworkAddressEntry* */ QNetworkInterface_addressEntries(const QNetworkInterface* self) { QList _ret = self->addressEntries(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkAddressEntry** _arr = static_cast(malloc(sizeof(QNetworkAddressEntry*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkAddressEntry** _arr = static_cast(malloc(sizeof(QNetworkAddressEntry*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkAddressEntry(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -226,12 +226,12 @@ struct miqt_string QNetworkInterface_interfaceNameFromIndex(int index) { struct miqt_array /* of QNetworkInterface* */ QNetworkInterface_allInterfaces() { QList _ret = QNetworkInterface::allInterfaces(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkInterface** _arr = static_cast(malloc(sizeof(QNetworkInterface*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkInterface** _arr = static_cast(malloc(sizeof(QNetworkInterface*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkInterface(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -239,12 +239,12 @@ struct miqt_array /* of QNetworkInterface* */ QNetworkInterface_allInterfaces() struct miqt_array /* of QHostAddress* */ QNetworkInterface_allAddresses() { QList _ret = QNetworkInterface::allAddresses(); // Convert QList<> from C++ memory to manually-managed C memory - QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QHostAddress** _arr = static_cast(malloc(sizeof(QHostAddress*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QHostAddress(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qnetworkproxy.cpp b/qt6/network/gen_qnetworkproxy.cpp index 6c9ffc0d95..ecbd571519 100644 --- a/qt6/network/gen_qnetworkproxy.cpp +++ b/qt6/network/gen_qnetworkproxy.cpp @@ -310,8 +310,8 @@ bool QNetworkProxy_hasRawHeader(const QNetworkProxy* self, struct miqt_string he struct miqt_array /* of struct miqt_string */ QNetworkProxy_rawHeaderList(const QNetworkProxy* self) { QList _ret = self->rawHeaderList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -320,7 +320,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkProxy_rawHeaderList(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -383,12 +383,12 @@ QNetworkProxyFactory* QNetworkProxyFactory_new() { struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_queryProxy(QNetworkProxyFactory* self, QNetworkProxyQuery* query) { QList _ret = self->queryProxy(*query); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -408,12 +408,12 @@ void QNetworkProxyFactory_setApplicationProxyFactory(QNetworkProxyFactory* facto struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_proxyForQuery(QNetworkProxyQuery* query) { QList _ret = QNetworkProxyFactory::proxyForQuery(*query); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -421,12 +421,12 @@ struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_proxyForQuery(QN struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_systemProxyForQuery() { QList _ret = QNetworkProxyFactory::systemProxyForQuery(); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -438,12 +438,12 @@ void QNetworkProxyFactory_operatorAssign(QNetworkProxyFactory* self, QNetworkPro struct miqt_array /* of QNetworkProxy* */ QNetworkProxyFactory_systemProxyForQueryWithQuery(QNetworkProxyQuery* query) { QList _ret = QNetworkProxyFactory::systemProxyForQuery(*query); // Convert QList<> from C++ memory to manually-managed C memory - QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QNetworkProxy** _arr = static_cast(malloc(sizeof(QNetworkProxy*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QNetworkProxy(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qnetworkreply.cpp b/qt6/network/gen_qnetworkreply.cpp index f8434031d7..feca7d4991 100644 --- a/qt6/network/gen_qnetworkreply.cpp +++ b/qt6/network/gen_qnetworkreply.cpp @@ -122,8 +122,8 @@ bool QNetworkReply_hasRawHeader(const QNetworkReply* self, struct miqt_string he struct miqt_array /* of struct miqt_string */ QNetworkReply_rawHeaderList(const QNetworkReply* self) { QList _ret = self->rawHeaderList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -132,7 +132,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkReply_rawHeaderList(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -148,10 +148,10 @@ struct miqt_string QNetworkReply_rawHeader(const QNetworkReply* self, struct miq } struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct miqt_string */ QNetworkReply_rawHeaderPairs(const QNetworkReply* self) { - const QList& _ret = self->rawHeaderPairs(); + const QList>& _ret = self->rawHeaderPairs(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ * _arr = static_cast(malloc(sizeof(struct miqt_map /* tuple of struct miqt_string and struct miqt_string */ ) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPair _lv_ret = _ret[i]; // Convert QPair<> from C++ memory to manually-managed C memory struct miqt_string* _lv_first_arr = static_cast(malloc(sizeof(struct miqt_string))); @@ -175,7 +175,7 @@ struct miqt_array /* of struct miqt_map tuple of struct miqt_string and struct _arr[i] = _lv_out; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -286,12 +286,12 @@ void QNetworkReply_connect_sslErrors(QNetworkReply* self, intptr_t slot) { QNetworkReply::connect(self, static_cast&)>(&QNetworkReply::sslErrors), self, [=](const QList& errors) { const QList& errors_ret = errors; // Convert QList<> from C++ memory to manually-managed C memory - QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.size())); + for (size_t i = 0, e = errors_ret.size(); i < e; ++i) { errors_arr[i] = new QSslError(errors_ret[i]); } struct miqt_array errors_out; - errors_out.len = errors_ret.length(); + errors_out.len = errors_ret.size(); errors_out.data = static_cast(errors_arr); struct miqt_array /* of QSslError* */ sigval1 = errors_out; miqt_exec_callback_QNetworkReply_sslErrors(slot, sigval1); diff --git a/qt6/network/gen_qnetworkrequest.cpp b/qt6/network/gen_qnetworkrequest.cpp index 016800b1e7..23a61c8b71 100644 --- a/qt6/network/gen_qnetworkrequest.cpp +++ b/qt6/network/gen_qnetworkrequest.cpp @@ -72,8 +72,8 @@ bool QNetworkRequest_hasRawHeader(const QNetworkRequest* self, struct miqt_strin struct miqt_array /* of struct miqt_string */ QNetworkRequest_rawHeaderList(const QNetworkRequest* self) { QList _ret = self->rawHeaderList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -82,7 +82,7 @@ struct miqt_array /* of struct miqt_string */ QNetworkRequest_rawHeaderList(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qsslcertificate.cpp b/qt6/network/gen_qsslcertificate.cpp index 3968282f2b..e3c00cd96e 100644 --- a/qt6/network/gen_qsslcertificate.cpp +++ b/qt6/network/gen_qsslcertificate.cpp @@ -106,10 +106,10 @@ struct miqt_string QSslCertificate_digest(const QSslCertificate* self) { } struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfo(const QSslCertificate* self, int info) { - QStringList _ret = self->issuerInfo(static_cast(info)); + QList _ret = self->issuerInfo(static_cast(info)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -120,17 +120,17 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfo(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoWithAttribute(const QSslCertificate* self, struct miqt_string attribute) { QByteArray attribute_QByteArray(attribute.data, attribute.len); - QStringList _ret = self->issuerInfo(attribute_QByteArray); + QList _ret = self->issuerInfo(attribute_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -141,16 +141,16 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoWithAtt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfo(const QSslCertificate* self, int info) { - QStringList _ret = self->subjectInfo(static_cast(info)); + QList _ret = self->subjectInfo(static_cast(info)); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -161,17 +161,17 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfo(const _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoWithAttribute(const QSslCertificate* self, struct miqt_string attribute) { QByteArray attribute_QByteArray(attribute.data, attribute.len); - QStringList _ret = self->subjectInfo(attribute_QByteArray); + QList _ret = self->subjectInfo(attribute_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -182,7 +182,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoWithAt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -212,8 +212,8 @@ struct miqt_string QSslCertificate_subjectDisplayName(const QSslCertificate* sel struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoAttributes(const QSslCertificate* self) { QList _ret = self->subjectInfoAttributes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -222,7 +222,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoAttrib _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -230,8 +230,8 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_subjectInfoAttrib struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoAttributes(const QSslCertificate* self) { QList _ret = self->issuerInfoAttributes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -240,7 +240,7 @@ struct miqt_array /* of struct miqt_string */ QSslCertificate_issuerInfoAttribu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -260,12 +260,12 @@ QSslKey* QSslCertificate_publicKey(const QSslCertificate* self) { struct miqt_array /* of QSslCertificateExtension* */ QSslCertificate_extensions(const QSslCertificate* self) { QList _ret = self->extensions(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificateExtension** _arr = static_cast(malloc(sizeof(QSslCertificateExtension*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificateExtension** _arr = static_cast(malloc(sizeof(QSslCertificateExtension*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificateExtension(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -303,12 +303,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath(struct miq QString path_QString = QString::fromUtf8(path.data, path.len); QList _ret = QSslCertificate::fromPath(path_QString); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -316,12 +316,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath(struct miq struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromDevice(QIODevice* device) { QList _ret = QSslCertificate::fromDevice(device); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -330,12 +330,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromData(struct miq QByteArray data_QByteArray(data.data, data.len); QList _ret = QSslCertificate::fromData(data_QByteArray); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -349,12 +349,12 @@ struct miqt_array /* of QSslError* */ QSslCertificate_verify(struct miqt_array } QList _ret = QSslCertificate::verify(certificateChain_QList); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -381,12 +381,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath2(struct mi QString path_QString = QString::fromUtf8(path.data, path.len); QList _ret = QSslCertificate::fromPath(path_QString, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -395,12 +395,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath3(struct mi QString path_QString = QString::fromUtf8(path.data, path.len); QList _ret = QSslCertificate::fromPath(path_QString, static_cast(format), static_cast(syntax)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -408,12 +408,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromPath3(struct mi struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromDevice2(QIODevice* device, int format) { QList _ret = QSslCertificate::fromDevice(device, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -422,12 +422,12 @@ struct miqt_array /* of QSslCertificate* */ QSslCertificate_fromData2(struct mi QByteArray data_QByteArray(data.data, data.len); QList _ret = QSslCertificate::fromData(data_QByteArray, static_cast(format)); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -442,12 +442,12 @@ struct miqt_array /* of QSslError* */ QSslCertificate_verify2(struct miqt_array QString hostName_QString = QString::fromUtf8(hostName.data, hostName.len); QList _ret = QSslCertificate::verify(certificateChain_QList, hostName_QString); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qsslconfiguration.cpp b/qt6/network/gen_qsslconfiguration.cpp index 81689cfb48..e57607ee27 100644 --- a/qt6/network/gen_qsslconfiguration.cpp +++ b/qt6/network/gen_qsslconfiguration.cpp @@ -78,12 +78,12 @@ void QSslConfiguration_setPeerVerifyDepth(QSslConfiguration* self, int depth) { struct miqt_array /* of QSslCertificate* */ QSslConfiguration_localCertificateChain(const QSslConfiguration* self) { QList _ret = self->localCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -113,12 +113,12 @@ QSslCertificate* QSslConfiguration_peerCertificate(const QSslConfiguration* self struct miqt_array /* of QSslCertificate* */ QSslConfiguration_peerCertificateChain(const QSslConfiguration* self) { QList _ret = self->peerCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -143,12 +143,12 @@ void QSslConfiguration_setPrivateKey(QSslConfiguration* self, QSslKey* key) { struct miqt_array /* of QSslCipher* */ QSslConfiguration_ciphers(const QSslConfiguration* self) { QList _ret = self->ciphers(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCipher(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -171,12 +171,12 @@ void QSslConfiguration_setCiphersWithCiphers(QSslConfiguration* self, struct miq struct miqt_array /* of QSslCipher* */ QSslConfiguration_supportedCiphers() { QList _ret = QSslConfiguration::supportedCiphers(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCipher** _arr = static_cast(malloc(sizeof(QSslCipher*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCipher(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -184,12 +184,12 @@ struct miqt_array /* of QSslCipher* */ QSslConfiguration_supportedCiphers() { struct miqt_array /* of QSslCertificate* */ QSslConfiguration_caCertificates(const QSslConfiguration* self) { QList _ret = self->caCertificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -226,12 +226,12 @@ void QSslConfiguration_addCaCertificatesWithCertificates(QSslConfiguration* self struct miqt_array /* of QSslCertificate* */ QSslConfiguration_systemCaCertificates() { QList _ret = QSslConfiguration::systemCaCertificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -269,12 +269,12 @@ QSslKey* QSslConfiguration_ephemeralServerKey(const QSslConfiguration* self) { struct miqt_array /* of QSslEllipticCurve* */ QSslConfiguration_ellipticCurves(const QSslConfiguration* self) { QList _ret = self->ellipticCurves(); // Convert QList<> from C++ memory to manually-managed C memory - QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslEllipticCurve(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -292,12 +292,12 @@ void QSslConfiguration_setEllipticCurves(QSslConfiguration* self, struct miqt_ar struct miqt_array /* of QSslEllipticCurve* */ QSslConfiguration_supportedEllipticCurves() { QList _ret = QSslConfiguration::supportedEllipticCurves(); // Convert QList<> from C++ memory to manually-managed C memory - QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslEllipticCurve** _arr = static_cast(malloc(sizeof(QSslEllipticCurve*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslEllipticCurve(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -413,8 +413,8 @@ void QSslConfiguration_setAllowedNextProtocols(QSslConfiguration* self, struct m struct miqt_array /* of struct miqt_string */ QSslConfiguration_allowedNextProtocols(const QSslConfiguration* self) { QList _ret = self->allowedNextProtocols(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -423,7 +423,7 @@ struct miqt_array /* of struct miqt_string */ QSslConfiguration_allowedNextProt _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/network/gen_qsslserver.cpp b/qt6/network/gen_qsslserver.cpp index 9643939375..6d045435e5 100644 --- a/qt6/network/gen_qsslserver.cpp +++ b/qt6/network/gen_qsslserver.cpp @@ -292,12 +292,12 @@ void QSslServer_connect_sslErrors(QSslServer* self, intptr_t slot) { QSslSocket* sigval1 = socket; const QList& errors_ret = errors; // Convert QList<> from C++ memory to manually-managed C memory - QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.size())); + for (size_t i = 0, e = errors_ret.size(); i < e; ++i) { errors_arr[i] = new QSslError(errors_ret[i]); } struct miqt_array errors_out; - errors_out.len = errors_ret.length(); + errors_out.len = errors_ret.size(); errors_out.data = static_cast(errors_arr); struct miqt_array /* of QSslError* */ sigval2 = errors_out; miqt_exec_callback_QSslServer_sslErrors(slot, sigval1, sigval2); diff --git a/qt6/network/gen_qsslsocket.cpp b/qt6/network/gen_qsslsocket.cpp index 3ea55ca7c8..b9992581c2 100644 --- a/qt6/network/gen_qsslsocket.cpp +++ b/qt6/network/gen_qsslsocket.cpp @@ -881,12 +881,12 @@ void QSslSocket_setLocalCertificateChain(QSslSocket* self, struct miqt_array /* struct miqt_array /* of QSslCertificate* */ QSslSocket_localCertificateChain(const QSslSocket* self) { QList _ret = self->localCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -911,12 +911,12 @@ QSslCertificate* QSslSocket_peerCertificate(const QSslSocket* self) { struct miqt_array /* of QSslCertificate* */ QSslSocket_peerCertificateChain(const QSslSocket* self) { QList _ret = self->peerCertificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -933,12 +933,12 @@ int QSslSocket_sessionProtocol(const QSslSocket* self) { struct miqt_array /* of QOcspResponse* */ QSslSocket_ocspResponses(const QSslSocket* self) { QList _ret = self->ocspResponses(); // Convert QList<> from C++ memory to manually-managed C memory - QOcspResponse** _arr = static_cast(malloc(sizeof(QOcspResponse*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QOcspResponse** _arr = static_cast(malloc(sizeof(QOcspResponse*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QOcspResponse(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -979,12 +979,12 @@ bool QSslSocket_waitForDisconnected(QSslSocket* self, int msecs) { struct miqt_array /* of QSslError* */ QSslSocket_sslHandshakeErrors(const QSslSocket* self) { QList _ret = self->sslHandshakeErrors(); // Convert QList<> from C++ memory to manually-managed C memory - QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslError** _arr = static_cast(malloc(sizeof(QSslError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1026,8 +1026,8 @@ struct miqt_string QSslSocket_sslLibraryBuildVersionString() { struct miqt_array /* of struct miqt_string */ QSslSocket_availableBackends() { QList _ret = QSslSocket::availableBackends(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1038,7 +1038,7 @@ struct miqt_array /* of struct miqt_string */ QSslSocket_availableBackends() { _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1062,13 +1062,13 @@ bool QSslSocket_setActiveBackend(struct miqt_string backendName) { struct miqt_array /* of int */ QSslSocket_supportedProtocols() { QList _ret = QSslSocket::supportedProtocols(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QSsl::SslProtocol _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1080,13 +1080,13 @@ bool QSslSocket_isProtocolSupported(int protocol) { struct miqt_array /* of int */ QSslSocket_implementedClasses() { QList _ret = QSslSocket::implementedClasses(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QSsl::ImplementedClass _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1098,13 +1098,13 @@ bool QSslSocket_isClassImplemented(int cl) { struct miqt_array /* of int */ QSslSocket_supportedFeatures() { QList _ret = QSslSocket::supportedFeatures(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QSsl::SupportedFeature _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1176,12 +1176,12 @@ void QSslSocket_connect_sslErrors(QSslSocket* self, intptr_t slot) { QSslSocket::connect(self, static_cast&)>(&QSslSocket::sslErrors), self, [=](const QList& errors) { const QList& errors_ret = errors; // Convert QList<> from C++ memory to manually-managed C memory - QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.length())); - for (size_t i = 0, e = errors_ret.length(); i < e; ++i) { + QSslError** errors_arr = static_cast(malloc(sizeof(QSslError*) * errors_ret.size())); + for (size_t i = 0, e = errors_ret.size(); i < e; ++i) { errors_arr[i] = new QSslError(errors_ret[i]); } struct miqt_array errors_out; - errors_out.len = errors_ret.length(); + errors_out.len = errors_ret.size(); errors_out.data = static_cast(errors_arr); struct miqt_array /* of QSslError* */ sigval1 = errors_out; miqt_exec_callback_QSslSocket_sslErrors(slot, sigval1); @@ -1365,13 +1365,13 @@ struct miqt_array /* of int */ QSslSocket_supportedProtocolsWithBackendName(str QString backendName_QString = QString::fromUtf8(backendName.data, backendName.len); QList _ret = QSslSocket::supportedProtocols(backendName_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QSsl::SslProtocol _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1385,13 +1385,13 @@ struct miqt_array /* of int */ QSslSocket_implementedClassesWithBackendName(str QString backendName_QString = QString::fromUtf8(backendName.data, backendName.len); QList _ret = QSslSocket::implementedClasses(backendName_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QSsl::ImplementedClass _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1405,13 +1405,13 @@ struct miqt_array /* of int */ QSslSocket_supportedFeaturesWithBackendName(stru QString backendName_QString = QString::fromUtf8(backendName.data, backendName.len); QList _ret = QSslSocket::supportedFeatures(backendName_QString); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QSsl::SupportedFeature _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/pdf/gen_qpdfbookmarkmodel.cpp b/qt6/pdf/gen_qpdfbookmarkmodel.cpp index 8082ce30b9..0475900254 100644 --- a/qt6/pdf/gen_qpdfbookmarkmodel.cpp +++ b/qt6/pdf/gen_qpdfbookmarkmodel.cpp @@ -380,13 +380,13 @@ class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QPdfBookmarkModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -402,19 +402,19 @@ class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QPdfBookmarkModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QPdfBookmarkModel_mimeData(this, handle__mimeData, sigval1); @@ -723,7 +723,7 @@ class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QPdfBookmarkModel::match(start, role, value, hits, flags); } @@ -739,7 +739,7 @@ class MiqtVirtualQPdfBookmarkModel final : public QPdfBookmarkModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfBookmarkModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -1345,10 +1345,10 @@ bool QPdfBookmarkModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QPdfBookmarkModel::mimeTypes(); + QList _ret = static_cast(self)->QPdfBookmarkModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1359,7 +1359,7 @@ struct miqt_array /* of struct miqt_string */ QPdfBookmarkModel_virtualbase_mim _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1375,7 +1375,7 @@ bool QPdfBookmarkModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QPdfBookmarkModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1608,14 +1608,14 @@ bool QPdfBookmarkModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QPdfBookmarkModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QPdfBookmarkModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1807,7 +1807,7 @@ void QPdfBookmarkModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const vo } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -2000,13 +2000,13 @@ void QPdfBookmarkModel_protectedbase_changePersistentIndexList(bool* _dynamic_ca } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -2023,14 +2023,14 @@ struct miqt_array /* of QModelIndex* */ QPdfBookmarkModel_protectedbase_persist } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/pdf/gen_qpdflink.cpp b/qt6/pdf/gen_qpdflink.cpp index f83dd08488..80e12d24e1 100644 --- a/qt6/pdf/gen_qpdflink.cpp +++ b/qt6/pdf/gen_qpdflink.cpp @@ -79,12 +79,12 @@ struct miqt_string QPdfLink_contextAfter(const QPdfLink* self) { struct miqt_array /* of QRectF* */ QPdfLink_rectangles(const QPdfLink* self) { QList _ret = self->rectangles(); // Convert QList<> from C++ memory to manually-managed C memory - QRectF** _arr = static_cast(malloc(sizeof(QRectF*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QRectF** _arr = static_cast(malloc(sizeof(QRectF*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QRectF(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/pdf/gen_qpdfsearchmodel.cpp b/qt6/pdf/gen_qpdfsearchmodel.cpp index e5b45d21f2..f536ceb323 100644 --- a/qt6/pdf/gen_qpdfsearchmodel.cpp +++ b/qt6/pdf/gen_qpdfsearchmodel.cpp @@ -384,13 +384,13 @@ class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { intptr_t handle__mimeTypes = 0; // Subclass to allow providing a Go implementation - virtual QStringList mimeTypes() const override { + virtual QList mimeTypes() const override { if (handle__mimeTypes == 0) { return QPdfSearchModel::mimeTypes(); } struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeTypes(this, handle__mimeTypes); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -406,19 +406,19 @@ class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { intptr_t handle__mimeData = 0; // Subclass to allow providing a Go implementation - virtual QMimeData* mimeData(const QModelIndexList& indexes) const override { + virtual QMimeData* mimeData(const QList& indexes) const override { if (handle__mimeData == 0) { return QPdfSearchModel::mimeData(indexes); } - const QModelIndexList& indexes_ret = indexes; + const QList& indexes_ret = indexes; // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.length())); - for (size_t i = 0, e = indexes_ret.length(); i < e; ++i) { + QModelIndex** indexes_arr = static_cast(malloc(sizeof(QModelIndex*) * indexes_ret.size())); + for (size_t i = 0, e = indexes_ret.size(); i < e; ++i) { indexes_arr[i] = new QModelIndex(indexes_ret[i]); } struct miqt_array indexes_out; - indexes_out.len = indexes_ret.length(); + indexes_out.len = indexes_ret.size(); indexes_out.data = static_cast(indexes_arr); struct miqt_array /* of QModelIndex* */ sigval1 = indexes_out; QMimeData* callback_return_value = miqt_exec_callback_QPdfSearchModel_mimeData(this, handle__mimeData, sigval1); @@ -686,7 +686,7 @@ class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { intptr_t handle__match = 0; // Subclass to allow providing a Go implementation - virtual QModelIndexList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { + virtual QList match(const QModelIndex& start, int role, const QVariant& value, int hits, Qt::MatchFlags flags) const override { if (handle__match == 0) { return QPdfSearchModel::match(start, role, value, hits, flags); } @@ -702,7 +702,7 @@ class MiqtVirtualQPdfSearchModel final : public QPdfSearchModel { Qt::MatchFlags flags_ret = flags; int sigval5 = static_cast(flags_ret); struct miqt_array /* of QModelIndex* */ callback_return_value = miqt_exec_callback_QPdfSearchModel_match(this, handle__match, sigval1, sigval2, sigval3, sigval4, sigval5); - QModelIndexList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); QModelIndex** callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -965,12 +965,12 @@ struct miqt_string QPdfSearchModel_tr(const char* s) { struct miqt_array /* of QPdfLink* */ QPdfSearchModel_resultsOnPage(const QPdfSearchModel* self, int page) { QList _ret = self->resultsOnPage(static_cast(page)); // Convert QList<> from C++ memory to manually-managed C memory - QPdfLink** _arr = static_cast(malloc(sizeof(QPdfLink*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPdfLink** _arr = static_cast(malloc(sizeof(QPdfLink*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPdfLink(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1323,10 +1323,10 @@ bool QPdfSearchModel_override_virtual_mimeTypes(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeTypes(const void* self) { - QStringList _ret = static_cast(self)->QPdfSearchModel::mimeTypes(); + QList _ret = static_cast(self)->QPdfSearchModel::mimeTypes(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1337,7 +1337,7 @@ struct miqt_array /* of struct miqt_string */ QPdfSearchModel_virtualbase_mimeT _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1353,7 +1353,7 @@ bool QPdfSearchModel_override_virtual_mimeData(void* self, intptr_t slot) { } QMimeData* QPdfSearchModel_virtualbase_mimeData(const void* self, struct miqt_array /* of QModelIndex* */ indexes) { - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1557,14 +1557,14 @@ bool QPdfSearchModel_override_virtual_match(void* self, intptr_t slot) { } struct miqt_array /* of QModelIndex* */ QPdfSearchModel_virtualbase_match(const void* self, QModelIndex* start, int role, QVariant* value, int hits, int flags) { - QModelIndexList _ret = static_cast(self)->QPdfSearchModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); + QList _ret = static_cast(self)->QPdfSearchModel::match(*start, static_cast(role), *value, static_cast(hits), static_cast(flags)); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -1753,7 +1753,7 @@ void QPdfSearchModel_protectedbase_encodeData(bool* _dynamic_cast_ok, const void } *_dynamic_cast_ok = true; - QModelIndexList indexes_QList; + QList indexes_QList; indexes_QList.reserve(indexes.len); QModelIndex** indexes_arr = static_cast(indexes.data); for(size_t i = 0; i < indexes.len; ++i) { @@ -1946,13 +1946,13 @@ void QPdfSearchModel_protectedbase_changePersistentIndexList(bool* _dynamic_cast } *_dynamic_cast_ok = true; - QModelIndexList from_QList; + QList from_QList; from_QList.reserve(from.len); QModelIndex** from_arr = static_cast(from.data); for(size_t i = 0; i < from.len; ++i) { from_QList.push_back(*(from_arr[i])); } - QModelIndexList to_QList; + QList to_QList; to_QList.reserve(to.len); QModelIndex** to_arr = static_cast(to.data); for(size_t i = 0; i < to.len; ++i) { @@ -1969,14 +1969,14 @@ struct miqt_array /* of QModelIndex* */ QPdfSearchModel_protectedbase_persisten } *_dynamic_cast_ok = true; - QModelIndexList _ret = self_cast->persistentIndexList(); + QList _ret = self_cast->persistentIndexList(); // Convert QList<> from C++ memory to manually-managed C memory - QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QModelIndex** _arr = static_cast(malloc(sizeof(QModelIndex*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QModelIndex(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/printsupport/gen_qabstractprintdialog.cpp b/qt6/printsupport/gen_qabstractprintdialog.cpp index cd94a76728..8eb0a811e8 100644 --- a/qt6/printsupport/gen_qabstractprintdialog.cpp +++ b/qt6/printsupport/gen_qabstractprintdialog.cpp @@ -1028,7 +1028,7 @@ struct miqt_string QAbstractPrintDialog_tr(const char* s) { } void QAbstractPrintDialog_setOptionTabs(QAbstractPrintDialog* self, struct miqt_array /* of QWidget* */ tabs) { - QList tabs_QList; + QList tabs_QList; tabs_QList.reserve(tabs.len); QWidget** tabs_arr = static_cast(tabs.data); for(size_t i = 0; i < tabs.len; ++i) { diff --git a/qt6/printsupport/gen_qprinter.cpp b/qt6/printsupport/gen_qprinter.cpp index 9abb719dd1..a6f16f842f 100644 --- a/qt6/printsupport/gen_qprinter.cpp +++ b/qt6/printsupport/gen_qprinter.cpp @@ -455,12 +455,12 @@ int QPrinter_duplex(const QPrinter* self) { struct miqt_array /* of int */ QPrinter_supportedResolutions(const QPrinter* self) { QList _ret = self->supportedResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/printsupport/gen_qprinterinfo.cpp b/qt6/printsupport/gen_qprinterinfo.cpp index eaa9fbef54..1c4f8b259f 100644 --- a/qt6/printsupport/gen_qprinterinfo.cpp +++ b/qt6/printsupport/gen_qprinterinfo.cpp @@ -96,12 +96,12 @@ int QPrinterInfo_state(const QPrinterInfo* self) { struct miqt_array /* of QPageSize* */ QPrinterInfo_supportedPageSizes(const QPrinterInfo* self) { QList _ret = self->supportedPageSizes(); // Convert QList<> from C++ memory to manually-managed C memory - QPageSize** _arr = static_cast(malloc(sizeof(QPageSize*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPageSize** _arr = static_cast(malloc(sizeof(QPageSize*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPageSize(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -125,12 +125,12 @@ QPageSize* QPrinterInfo_maximumPhysicalPageSize(const QPrinterInfo* self) { struct miqt_array /* of int */ QPrinterInfo_supportedResolutions(const QPrinterInfo* self) { QList _ret = self->supportedResolutions(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -143,13 +143,13 @@ int QPrinterInfo_defaultDuplexMode(const QPrinterInfo* self) { struct miqt_array /* of int */ QPrinterInfo_supportedDuplexModes(const QPrinterInfo* self) { QList _ret = self->supportedDuplexModes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPrinter::DuplexMode _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -162,22 +162,22 @@ int QPrinterInfo_defaultColorMode(const QPrinterInfo* self) { struct miqt_array /* of int */ QPrinterInfo_supportedColorModes(const QPrinterInfo* self) { QList _ret = self->supportedColorModes(); // Convert QList<> from C++ memory to manually-managed C memory - int* _arr = static_cast(malloc(sizeof(int) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + int* _arr = static_cast(malloc(sizeof(int) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QPrinter::ColorMode _lv_ret = _ret[i]; _arr[i] = static_cast(_lv_ret); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QPrinterInfo_availablePrinterNames() { - QStringList _ret = QPrinterInfo::availablePrinterNames(); + QList _ret = QPrinterInfo::availablePrinterNames(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -188,7 +188,7 @@ struct miqt_array /* of struct miqt_string */ QPrinterInfo_availablePrinterName _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -196,12 +196,12 @@ struct miqt_array /* of struct miqt_string */ QPrinterInfo_availablePrinterName struct miqt_array /* of QPrinterInfo* */ QPrinterInfo_availablePrinters() { QList _ret = QPrinterInfo::availablePrinters(); // Convert QList<> from C++ memory to manually-managed C memory - QPrinterInfo** _arr = static_cast(malloc(sizeof(QPrinterInfo*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QPrinterInfo** _arr = static_cast(malloc(sizeof(QPrinterInfo*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QPrinterInfo(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/qml/gen_qjsengine.cpp b/qt6/qml/gen_qjsengine.cpp index 4822c9d1c5..a715e44c85 100644 --- a/qt6/qml/gen_qjsengine.cpp +++ b/qt6/qml/gen_qjsengine.cpp @@ -350,7 +350,7 @@ QJSValue* QJSEngine_evaluate3(QJSEngine* self, struct miqt_string program, struc QJSValue* QJSEngine_evaluate4(QJSEngine* self, struct miqt_string program, struct miqt_string fileName, int lineNumber, struct miqt_array /* of struct miqt_string */ exceptionStackTrace) { QString program_QString = QString::fromUtf8(program.data, program.len); QString fileName_QString = QString::fromUtf8(fileName.data, fileName.len); - QStringList exceptionStackTrace_QList; + QList exceptionStackTrace_QList; exceptionStackTrace_QList.reserve(exceptionStackTrace.len); struct miqt_string* exceptionStackTrace_arr = static_cast(exceptionStackTrace.data); for(size_t i = 0; i < exceptionStackTrace.len; ++i) { diff --git a/qt6/qml/gen_qjsmanagedvalue.cpp b/qt6/qml/gen_qjsmanagedvalue.cpp index b354421ced..8f4e7435e2 100644 --- a/qt6/qml/gen_qjsmanagedvalue.cpp +++ b/qt6/qml/gen_qjsmanagedvalue.cpp @@ -258,10 +258,10 @@ QJSManagedValue* QJSManagedValue_jsMetaType(const QJSManagedValue* self) { } struct miqt_array /* of struct miqt_string */ QJSManagedValue_jsMetaMembers(const QJSManagedValue* self) { - QStringList _ret = self->jsMetaMembers(); + QList _ret = self->jsMetaMembers(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -272,7 +272,7 @@ struct miqt_array /* of struct miqt_string */ QJSManagedValue_jsMetaMembers(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -282,7 +282,7 @@ QJSManagedValue* QJSManagedValue_jsMetaInstantiate(const QJSManagedValue* self) } QJSValue* QJSManagedValue_callWithArguments(const QJSManagedValue* self, struct miqt_array /* of QJSValue* */ arguments) { - QJSValueList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); QJSValue** arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -292,7 +292,7 @@ QJSValue* QJSManagedValue_callWithArguments(const QJSManagedValue* self, struct } QJSValue* QJSManagedValue_callWithInstance2(const QJSManagedValue* self, QJSValue* instance, struct miqt_array /* of QJSValue* */ arguments) { - QJSValueList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); QJSValue** arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -302,7 +302,7 @@ QJSValue* QJSManagedValue_callWithInstance2(const QJSManagedValue* self, QJSValu } QJSValue* QJSManagedValue_callAsConstructorWithArguments(const QJSManagedValue* self, struct miqt_array /* of QJSValue* */ arguments) { - QJSValueList arguments_QList; + QList arguments_QList; arguments_QList.reserve(arguments.len); QJSValue** arguments_arr = static_cast(arguments.data); for(size_t i = 0; i < arguments.len; ++i) { @@ -312,7 +312,7 @@ QJSValue* QJSManagedValue_callAsConstructorWithArguments(const QJSManagedValue* } QJSManagedValue* QJSManagedValue_jsMetaInstantiateWithValues(const QJSManagedValue* self, struct miqt_array /* of QJSValue* */ values) { - QJSValueList values_QList; + QList values_QList; values_QList.reserve(values.len); QJSValue** values_arr = static_cast(values.data); for(size_t i = 0; i < values.len; ++i) { diff --git a/qt6/qml/gen_qjsvalue.cpp b/qt6/qml/gen_qjsvalue.cpp index d810de8327..3a48385f17 100644 --- a/qt6/qml/gen_qjsvalue.cpp +++ b/qt6/qml/gen_qjsvalue.cpp @@ -240,7 +240,7 @@ int QJSValue_errorType(const QJSValue* self) { } QJSValue* QJSValue_callWithArgs(const QJSValue* self, struct miqt_array /* of QJSValue* */ args) { - QJSValueList args_QList; + QList args_QList; args_QList.reserve(args.len); QJSValue** args_arr = static_cast(args.data); for(size_t i = 0; i < args.len; ++i) { @@ -250,7 +250,7 @@ QJSValue* QJSValue_callWithArgs(const QJSValue* self, struct miqt_array /* of QJ } QJSValue* QJSValue_callWithInstance2(const QJSValue* self, QJSValue* instance, struct miqt_array /* of QJSValue* */ args) { - QJSValueList args_QList; + QList args_QList; args_QList.reserve(args.len); QJSValue** args_arr = static_cast(args.data); for(size_t i = 0; i < args.len; ++i) { @@ -260,7 +260,7 @@ QJSValue* QJSValue_callWithInstance2(const QJSValue* self, QJSValue* instance, s } QJSValue* QJSValue_callAsConstructorWithArgs(const QJSValue* self, struct miqt_array /* of QJSValue* */ args) { - QJSValueList args_QList; + QList args_QList; args_QList.reserve(args.len); QJSValue** args_arr = static_cast(args.data); for(size_t i = 0; i < args.len; ++i) { diff --git a/qt6/qml/gen_qqmlapplicationengine.cpp b/qt6/qml/gen_qqmlapplicationengine.cpp index dfe3eecb77..fd2208727f 100644 --- a/qt6/qml/gen_qqmlapplicationengine.cpp +++ b/qt6/qml/gen_qqmlapplicationengine.cpp @@ -226,14 +226,14 @@ struct miqt_string QQmlApplicationEngine_tr(const char* s) { } struct miqt_array /* of QObject* */ QQmlApplicationEngine_rootObjects(const QQmlApplicationEngine* self) { - QList _ret = self->rootObjects(); + QList _ret = self->rootObjects(); // Convert QList<> from C++ memory to manually-managed C memory - QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QObject** _arr = static_cast(malloc(sizeof(QObject*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -248,7 +248,7 @@ void QQmlApplicationEngine_loadWithFilePath(QQmlApplicationEngine* self, struct } void QQmlApplicationEngine_setInitialProperties(QQmlApplicationEngine* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialProperties) { - QVariantMap initialProperties_QMap; + QMap initialProperties_QMap; struct miqt_string* initialProperties_karr = static_cast(initialProperties.keys); QVariant** initialProperties_varr = static_cast(initialProperties.values); for(size_t i = 0; i < initialProperties.len; ++i) { @@ -259,7 +259,7 @@ void QQmlApplicationEngine_setInitialProperties(QQmlApplicationEngine* self, str } void QQmlApplicationEngine_setExtraFileSelectors(QQmlApplicationEngine* self, struct miqt_array /* of struct miqt_string */ extraFileSelectors) { - QStringList extraFileSelectors_QList; + QList extraFileSelectors_QList; extraFileSelectors_QList.reserve(extraFileSelectors.len); struct miqt_string* extraFileSelectors_arr = static_cast(extraFileSelectors.data); for(size_t i = 0; i < extraFileSelectors.len; ++i) { diff --git a/qt6/qml/gen_qqmlcomponent.cpp b/qt6/qml/gen_qqmlcomponent.cpp index 2cfc757eab..30f1ace27e 100644 --- a/qt6/qml/gen_qqmlcomponent.cpp +++ b/qt6/qml/gen_qqmlcomponent.cpp @@ -341,12 +341,12 @@ bool QQmlComponent_isBound(const QQmlComponent* self) { struct miqt_array /* of QQmlError* */ QQmlComponent_errors(const QQmlComponent* self) { QList _ret = self->errors(); // Convert QList<> from C++ memory to manually-managed C memory - QQmlError** _arr = static_cast(malloc(sizeof(QQmlError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QQmlError** _arr = static_cast(malloc(sizeof(QQmlError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QQmlError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -376,7 +376,7 @@ QObject* QQmlComponent_create(QQmlComponent* self, QQmlContext* context) { } QObject* QQmlComponent_createWithInitialProperties(QQmlComponent* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialProperties) { - QVariantMap initialProperties_QMap; + QMap initialProperties_QMap; struct miqt_string* initialProperties_karr = static_cast(initialProperties.keys); QVariant** initialProperties_varr = static_cast(initialProperties.values); for(size_t i = 0; i < initialProperties.len; ++i) { @@ -387,7 +387,7 @@ QObject* QQmlComponent_createWithInitialProperties(QQmlComponent* self, struct m } void QQmlComponent_setInitialProperties(QQmlComponent* self, QObject* component, struct miqt_map /* of struct miqt_string to QVariant* */ properties) { - QVariantMap properties_QMap; + QMap properties_QMap; struct miqt_string* properties_karr = static_cast(properties.keys); QVariant** properties_varr = static_cast(properties.values); for(size_t i = 0; i < properties.len; ++i) { @@ -477,7 +477,7 @@ struct miqt_string QQmlComponent_tr3(const char* s, const char* c, int n) { } QObject* QQmlComponent_createWithInitialProperties2(QQmlComponent* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialProperties, QQmlContext* context) { - QVariantMap initialProperties_QMap; + QMap initialProperties_QMap; struct miqt_string* initialProperties_karr = static_cast(initialProperties.keys); QVariant** initialProperties_varr = static_cast(initialProperties.values); for(size_t i = 0; i < initialProperties.len; ++i) { @@ -665,7 +665,7 @@ QObject* QQmlComponent_protectedbase_createObject3(bool* _dynamic_cast_ok, void* } *_dynamic_cast_ok = true; - QVariantMap properties_QMap; + QMap properties_QMap; struct miqt_string* properties_karr = static_cast(properties.keys); QVariant** properties_varr = static_cast(properties.values); for(size_t i = 0; i < properties.len; ++i) { diff --git a/qt6/qml/gen_qqmldebug.cpp b/qt6/qml/gen_qqmldebug.cpp index e17683fc2d..c43828ec91 100644 --- a/qt6/qml/gen_qqmldebug.cpp +++ b/qt6/qml/gen_qqmldebug.cpp @@ -29,10 +29,10 @@ void QQmlDebuggingEnabler_enableDebugging(bool printWarning) { } struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_debuggerServices() { - QStringList _ret = QQmlDebuggingEnabler::debuggerServices(); + QList _ret = QQmlDebuggingEnabler::debuggerServices(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -43,16 +43,16 @@ struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_debuggerServ _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_inspectorServices() { - QStringList _ret = QQmlDebuggingEnabler::inspectorServices(); + QList _ret = QQmlDebuggingEnabler::inspectorServices(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -63,16 +63,16 @@ struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_inspectorSer _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_profilerServices() { - QStringList _ret = QQmlDebuggingEnabler::profilerServices(); + QList _ret = QQmlDebuggingEnabler::profilerServices(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -83,16 +83,16 @@ struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_profilerServ _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_nativeDebuggerServices() { - QStringList _ret = QQmlDebuggingEnabler::nativeDebuggerServices(); + QList _ret = QQmlDebuggingEnabler::nativeDebuggerServices(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -103,13 +103,13 @@ struct miqt_array /* of struct miqt_string */ QQmlDebuggingEnabler_nativeDebugg _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QQmlDebuggingEnabler_setServices(struct miqt_array /* of struct miqt_string */ services) { - QStringList services_QList; + QList services_QList; services_QList.reserve(services.len); struct miqt_string* services_arr = static_cast(services.data); for(size_t i = 0; i < services.len; ++i) { @@ -149,7 +149,7 @@ bool QQmlDebuggingEnabler_connectToLocalDebugger2(struct miqt_string socketFileN bool QQmlDebuggingEnabler_startDebugConnector2(struct miqt_string pluginName, struct miqt_map /* of struct miqt_string to QVariant* */ configuration) { QString pluginName_QString = QString::fromUtf8(pluginName.data, pluginName.len); - QVariantHash configuration_QMap; + QHash configuration_QMap; configuration_QMap.reserve(configuration.len); struct miqt_string* configuration_karr = static_cast(configuration.keys); QVariant** configuration_varr = static_cast(configuration.values); diff --git a/qt6/qml/gen_qqmlengine.cpp b/qt6/qml/gen_qqmlengine.cpp index 0771165576..2e2fa6b547 100644 --- a/qt6/qml/gen_qqmlengine.cpp +++ b/qt6/qml/gen_qqmlengine.cpp @@ -283,10 +283,10 @@ void QQmlEngine_clearSingletons(QQmlEngine* self) { } struct miqt_array /* of struct miqt_string */ QQmlEngine_importPathList(const QQmlEngine* self) { - QStringList _ret = self->importPathList(); + QList _ret = self->importPathList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -297,13 +297,13 @@ struct miqt_array /* of struct miqt_string */ QQmlEngine_importPathList(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QQmlEngine_setImportPathList(QQmlEngine* self, struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { @@ -319,10 +319,10 @@ void QQmlEngine_addImportPath(QQmlEngine* self, struct miqt_string dir) { } struct miqt_array /* of struct miqt_string */ QQmlEngine_pluginPathList(const QQmlEngine* self) { - QStringList _ret = self->pluginPathList(); + QList _ret = self->pluginPathList(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -333,13 +333,13 @@ struct miqt_array /* of struct miqt_string */ QQmlEngine_pluginPathList(const Q _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } void QQmlEngine_setPluginPathList(QQmlEngine* self, struct miqt_array /* of struct miqt_string */ paths) { - QStringList paths_QList; + QList paths_QList; paths_QList.reserve(paths.len); struct miqt_string* paths_arr = static_cast(paths.data); for(size_t i = 0; i < paths.len; ++i) { @@ -397,14 +397,14 @@ void QQmlEngine_removeUrlInterceptor(QQmlEngine* self, QQmlAbstractUrlIntercepto } struct miqt_array /* of QQmlAbstractUrlInterceptor* */ QQmlEngine_urlInterceptors(const QQmlEngine* self) { - QList _ret = self->urlInterceptors(); + QList _ret = self->urlInterceptors(); // Convert QList<> from C++ memory to manually-managed C memory - QQmlAbstractUrlInterceptor** _arr = static_cast(malloc(sizeof(QQmlAbstractUrlInterceptor*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QQmlAbstractUrlInterceptor** _arr = static_cast(malloc(sizeof(QQmlAbstractUrlInterceptor*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = _ret[i]; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -531,12 +531,12 @@ void QQmlEngine_connect_warnings(QQmlEngine* self, intptr_t slot) { QQmlEngine::connect(self, static_cast&)>(&QQmlEngine::warnings), self, [=](const QList& warnings) { const QList& warnings_ret = warnings; // Convert QList<> from C++ memory to manually-managed C memory - QQmlError** warnings_arr = static_cast(malloc(sizeof(QQmlError*) * warnings_ret.length())); - for (size_t i = 0, e = warnings_ret.length(); i < e; ++i) { + QQmlError** warnings_arr = static_cast(malloc(sizeof(QQmlError*) * warnings_ret.size())); + for (size_t i = 0, e = warnings_ret.size(); i < e; ++i) { warnings_arr[i] = new QQmlError(warnings_ret[i]); } struct miqt_array warnings_out; - warnings_out.len = warnings_ret.length(); + warnings_out.len = warnings_ret.size(); warnings_out.data = static_cast(warnings_arr); struct miqt_array /* of QQmlError* */ sigval1 = warnings_out; miqt_exec_callback_QQmlEngine_warnings(slot, sigval1); diff --git a/qt6/qml/gen_qqmlfileselector.cpp b/qt6/qml/gen_qqmlfileselector.cpp index 281d459a1c..9eac552888 100644 --- a/qt6/qml/gen_qqmlfileselector.cpp +++ b/qt6/qml/gen_qqmlfileselector.cpp @@ -206,7 +206,7 @@ void QQmlFileSelector_setSelector(QQmlFileSelector* self, QFileSelector* selecto } void QQmlFileSelector_setExtraSelectors(QQmlFileSelector* self, struct miqt_array /* of struct miqt_string */ strings) { - QStringList strings_QList; + QList strings_QList; strings_QList.reserve(strings.len); struct miqt_string* strings_arr = static_cast(strings.data); for(size_t i = 0; i < strings.len; ++i) { diff --git a/qt6/qml/gen_qqmlincubator.cpp b/qt6/qml/gen_qqmlincubator.cpp index af1151056b..dbd5921249 100644 --- a/qt6/qml/gen_qqmlincubator.cpp +++ b/qt6/qml/gen_qqmlincubator.cpp @@ -103,12 +103,12 @@ bool QQmlIncubator_isLoading(const QQmlIncubator* self) { struct miqt_array /* of QQmlError* */ QQmlIncubator_errors(const QQmlIncubator* self) { QList _ret = self->errors(); // Convert QList<> from C++ memory to manually-managed C memory - QQmlError** _arr = static_cast(malloc(sizeof(QQmlError*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QQmlError** _arr = static_cast(malloc(sizeof(QQmlError*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QQmlError(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -128,7 +128,7 @@ QObject* QQmlIncubator_object(const QQmlIncubator* self) { } void QQmlIncubator_setInitialProperties(QQmlIncubator* self, struct miqt_map /* of struct miqt_string to QVariant* */ initialProperties) { - QVariantMap initialProperties_QMap; + QMap initialProperties_QMap; struct miqt_string* initialProperties_karr = static_cast(initialProperties.keys); QVariant** initialProperties_varr = static_cast(initialProperties.values); for(size_t i = 0; i < initialProperties.len; ++i) { diff --git a/qt6/qml/gen_qqmlpropertymap.cpp b/qt6/qml/gen_qqmlpropertymap.cpp index bc70c586ab..49362bb707 100644 --- a/qt6/qml/gen_qqmlpropertymap.cpp +++ b/qt6/qml/gen_qqmlpropertymap.cpp @@ -236,7 +236,7 @@ void QQmlPropertyMap_insert(QQmlPropertyMap* self, struct miqt_string key, QVari } void QQmlPropertyMap_insertWithValues(QQmlPropertyMap* self, struct miqt_map /* of struct miqt_string to QVariant* */ values) { - QVariantHash values_QMap; + QHash values_QMap; values_QMap.reserve(values.len); struct miqt_string* values_karr = static_cast(values.keys); QVariant** values_varr = static_cast(values.values); @@ -257,10 +257,10 @@ void QQmlPropertyMap_freeze(QQmlPropertyMap* self) { } struct miqt_array /* of struct miqt_string */ QQmlPropertyMap_keys(const QQmlPropertyMap* self) { - QStringList _ret = self->keys(); + QList _ret = self->keys(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -271,7 +271,7 @@ struct miqt_array /* of struct miqt_string */ QQmlPropertyMap_keys(const QQmlPr _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webchannel/gen_qwebchannel.cpp b/qt6/webchannel/gen_qwebchannel.cpp index ef666f0d28..eb7e274f63 100644 --- a/qt6/webchannel/gen_qwebchannel.cpp +++ b/qt6/webchannel/gen_qwebchannel.cpp @@ -198,7 +198,7 @@ struct miqt_string QWebChannel_tr(const char* s) { } void QWebChannel_registerObjects(QWebChannel* self, struct miqt_map /* of struct miqt_string to QObject* */ objects) { - QHash objects_QMap; + QHash objects_QMap; objects_QMap.reserve(objects.len); struct miqt_string* objects_karr = static_cast(objects.keys); QObject** objects_varr = static_cast(objects.values); @@ -210,7 +210,7 @@ void QWebChannel_registerObjects(QWebChannel* self, struct miqt_map /* of struct } struct miqt_map /* of struct miqt_string to QObject* */ QWebChannel_registeredObjects(const QWebChannel* self) { - QHash _ret = self->registeredObjects(); + QHash _ret = self->registeredObjects(); // Convert QMap<> from C++ memory to manually-managed C memory struct miqt_string* _karr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); QObject** _varr = static_cast(malloc(sizeof(QObject*) * _ret.size())); diff --git a/qt6/webchannel/qmlwebchannel/gen_qqmlwebchannel.cpp b/qt6/webchannel/qmlwebchannel/gen_qqmlwebchannel.cpp index 851e605633..b3aa3f169c 100644 --- a/qt6/webchannel/qmlwebchannel/gen_qqmlwebchannel.cpp +++ b/qt6/webchannel/qmlwebchannel/gen_qqmlwebchannel.cpp @@ -198,7 +198,7 @@ struct miqt_string QQmlWebChannel_tr(const char* s) { } void QQmlWebChannel_registerObjects(QQmlWebChannel* self, struct miqt_map /* of struct miqt_string to QVariant* */ objects) { - QVariantMap objects_QMap; + QMap objects_QMap; struct miqt_string* objects_karr = static_cast(objects.keys); QVariant** objects_varr = static_cast(objects.values); for(size_t i = 0; i < objects.len; ++i) { diff --git a/qt6/webengine/gen_qwebenginecertificateerror.cpp b/qt6/webengine/gen_qwebenginecertificateerror.cpp index ca05b0d1c1..fadc974fdc 100644 --- a/qt6/webengine/gen_qwebenginecertificateerror.cpp +++ b/qt6/webengine/gen_qwebenginecertificateerror.cpp @@ -63,12 +63,12 @@ void QWebEngineCertificateError_acceptCertificate(QWebEngineCertificateError* se struct miqt_array /* of QSslCertificate* */ QWebEngineCertificateError_certificateChain(const QWebEngineCertificateError* self) { QList _ret = self->certificateChain(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebengineclientcertificateselection.cpp b/qt6/webengine/gen_qwebengineclientcertificateselection.cpp index 2cb3fd32d1..ff4cbf1a30 100644 --- a/qt6/webengine/gen_qwebengineclientcertificateselection.cpp +++ b/qt6/webengine/gen_qwebengineclientcertificateselection.cpp @@ -36,12 +36,12 @@ void QWebEngineClientCertificateSelection_selectNone(QWebEngineClientCertificate struct miqt_array /* of QSslCertificate* */ QWebEngineClientCertificateSelection_certificates(const QWebEngineClientCertificateSelection* self) { QList _ret = self->certificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebengineclientcertificatestore.cpp b/qt6/webengine/gen_qwebengineclientcertificatestore.cpp index e6b41d59d8..8cb1a3f456 100644 --- a/qt6/webengine/gen_qwebengineclientcertificatestore.cpp +++ b/qt6/webengine/gen_qwebengineclientcertificatestore.cpp @@ -20,12 +20,12 @@ void QWebEngineClientCertificateStore_add(QWebEngineClientCertificateStore* self struct miqt_array /* of QSslCertificate* */ QWebEngineClientCertificateStore_certificates(const QWebEngineClientCertificateStore* self) { QList _ret = self->certificates(); // Convert QList<> from C++ memory to manually-managed C memory - QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QSslCertificate** _arr = static_cast(malloc(sizeof(QSslCertificate*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QSslCertificate(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebenginecontextmenurequest.cpp b/qt6/webengine/gen_qwebenginecontextmenurequest.cpp index 4e328e4e75..c223e9173a 100644 --- a/qt6/webengine/gen_qwebenginecontextmenurequest.cpp +++ b/qt6/webengine/gen_qwebenginecontextmenurequest.cpp @@ -97,10 +97,10 @@ struct miqt_string QWebEngineContextMenuRequest_misspelledWord(const QWebEngineC } struct miqt_array /* of struct miqt_string */ QWebEngineContextMenuRequest_spellCheckerSuggestions(const QWebEngineContextMenuRequest* self) { - QStringList _ret = self->spellCheckerSuggestions(); + QList _ret = self->spellCheckerSuggestions(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -111,7 +111,7 @@ struct miqt_array /* of struct miqt_string */ QWebEngineContextMenuRequest_spel _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebenginehistory.cpp b/qt6/webengine/gen_qwebenginehistory.cpp index 2e18a2f1fd..479a463e61 100644 --- a/qt6/webengine/gen_qwebenginehistory.cpp +++ b/qt6/webengine/gen_qwebenginehistory.cpp @@ -185,12 +185,12 @@ void QWebEngineHistory_clear(QWebEngineHistory* self) { struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_items(const QWebEngineHistory* self) { QList _ret = self->items(); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -198,12 +198,12 @@ struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_items(const struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_backItems(const QWebEngineHistory* self, int maxItems) { QList _ret = self->backItems(static_cast(maxItems)); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -211,12 +211,12 @@ struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_backItems(c struct miqt_array /* of QWebEngineHistoryItem* */ QWebEngineHistory_forwardItems(const QWebEngineHistory* self, int maxItems) { QList _ret = self->forwardItems(static_cast(maxItems)); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineHistoryItem** _arr = static_cast(malloc(sizeof(QWebEngineHistoryItem*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineHistoryItem(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebenginehttprequest.cpp b/qt6/webengine/gen_qwebenginehttprequest.cpp index 410e699419..0e8457cbf6 100644 --- a/qt6/webengine/gen_qwebenginehttprequest.cpp +++ b/qt6/webengine/gen_qwebenginehttprequest.cpp @@ -100,8 +100,8 @@ bool QWebEngineHttpRequest_hasHeader(const QWebEngineHttpRequest* self, struct m struct miqt_array /* of struct miqt_string */ QWebEngineHttpRequest_headers(const QWebEngineHttpRequest* self) { QList _ret = self->headers(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { QByteArray _lv_qb = _ret[i]; struct miqt_string _lv_ms; _lv_ms.len = _lv_qb.length(); @@ -110,7 +110,7 @@ struct miqt_array /* of struct miqt_string */ QWebEngineHttpRequest_headers(con _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebenginepage.cpp b/qt6/webengine/gen_qwebenginepage.cpp index 0943820108..7e08b5b6d4 100644 --- a/qt6/webengine/gen_qwebenginepage.cpp +++ b/qt6/webengine/gen_qwebenginepage.cpp @@ -163,17 +163,17 @@ class MiqtVirtualQWebEnginePage final : public QWebEnginePage { intptr_t handle__chooseFiles = 0; // Subclass to allow providing a Go implementation - virtual QStringList chooseFiles(QWebEnginePage::FileSelectionMode mode, const QStringList& oldFiles, const QStringList& acceptedMimeTypes) override { + virtual QList chooseFiles(QWebEnginePage::FileSelectionMode mode, const QList& oldFiles, const QList& acceptedMimeTypes) override { if (handle__chooseFiles == 0) { return QWebEnginePage::chooseFiles(mode, oldFiles, acceptedMimeTypes); } QWebEnginePage::FileSelectionMode mode_ret = mode; int sigval1 = static_cast(mode_ret); - const QStringList& oldFiles_ret = oldFiles; + const QList& oldFiles_ret = oldFiles; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* oldFiles_arr = static_cast(malloc(sizeof(struct miqt_string) * oldFiles_ret.length())); - for (size_t i = 0, e = oldFiles_ret.length(); i < e; ++i) { + struct miqt_string* oldFiles_arr = static_cast(malloc(sizeof(struct miqt_string) * oldFiles_ret.size())); + for (size_t i = 0, e = oldFiles_ret.size(); i < e; ++i) { QString oldFiles_lv_ret = oldFiles_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray oldFiles_lv_b = oldFiles_lv_ret.toUtf8(); @@ -184,13 +184,13 @@ class MiqtVirtualQWebEnginePage final : public QWebEnginePage { oldFiles_arr[i] = oldFiles_lv_ms; } struct miqt_array oldFiles_out; - oldFiles_out.len = oldFiles_ret.length(); + oldFiles_out.len = oldFiles_ret.size(); oldFiles_out.data = static_cast(oldFiles_arr); struct miqt_array /* of struct miqt_string */ sigval2 = oldFiles_out; - const QStringList& acceptedMimeTypes_ret = acceptedMimeTypes; + const QList& acceptedMimeTypes_ret = acceptedMimeTypes; // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* acceptedMimeTypes_arr = static_cast(malloc(sizeof(struct miqt_string) * acceptedMimeTypes_ret.length())); - for (size_t i = 0, e = acceptedMimeTypes_ret.length(); i < e; ++i) { + struct miqt_string* acceptedMimeTypes_arr = static_cast(malloc(sizeof(struct miqt_string) * acceptedMimeTypes_ret.size())); + for (size_t i = 0, e = acceptedMimeTypes_ret.size(); i < e; ++i) { QString acceptedMimeTypes_lv_ret = acceptedMimeTypes_ret[i]; // Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory QByteArray acceptedMimeTypes_lv_b = acceptedMimeTypes_lv_ret.toUtf8(); @@ -201,11 +201,11 @@ class MiqtVirtualQWebEnginePage final : public QWebEnginePage { acceptedMimeTypes_arr[i] = acceptedMimeTypes_lv_ms; } struct miqt_array acceptedMimeTypes_out; - acceptedMimeTypes_out.len = acceptedMimeTypes_ret.length(); + acceptedMimeTypes_out.len = acceptedMimeTypes_ret.size(); acceptedMimeTypes_out.data = static_cast(acceptedMimeTypes_arr); struct miqt_array /* of struct miqt_string */ sigval3 = acceptedMimeTypes_out; struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QWebEnginePage_chooseFiles(this, handle__chooseFiles, sigval1, sigval2, sigval3); - QStringList callback_return_value_QList; + QList callback_return_value_QList; callback_return_value_QList.reserve(callback_return_value.len); struct miqt_string* callback_return_value_arr = static_cast(callback_return_value.data); for(size_t i = 0; i < callback_return_value.len; ++i) { @@ -518,10 +518,6 @@ bool QWebEnginePage_event(QWebEnginePage* self, QEvent* param1) { return self->event(param1); } -void QWebEnginePage_setFeaturePermission(QWebEnginePage* self, QUrl* securityOrigin, int feature, int policy) { - self->setFeaturePermission(*securityOrigin, static_cast(feature), static_cast(policy)); -} - bool QWebEnginePage_isLoading(const QWebEnginePage* self) { return self->isLoading(); } @@ -1277,24 +1273,24 @@ bool QWebEnginePage_override_virtual_chooseFiles(void* self, intptr_t slot) { } struct miqt_array /* of struct miqt_string */ QWebEnginePage_virtualbase_chooseFiles(void* self, int mode, struct miqt_array /* of struct miqt_string */ oldFiles, struct miqt_array /* of struct miqt_string */ acceptedMimeTypes) { - QStringList oldFiles_QList; + QList oldFiles_QList; oldFiles_QList.reserve(oldFiles.len); struct miqt_string* oldFiles_arr = static_cast(oldFiles.data); for(size_t i = 0; i < oldFiles.len; ++i) { QString oldFiles_arr_i_QString = QString::fromUtf8(oldFiles_arr[i].data, oldFiles_arr[i].len); oldFiles_QList.push_back(oldFiles_arr_i_QString); } - QStringList acceptedMimeTypes_QList; + QList acceptedMimeTypes_QList; acceptedMimeTypes_QList.reserve(acceptedMimeTypes.len); struct miqt_string* acceptedMimeTypes_arr = static_cast(acceptedMimeTypes.data); for(size_t i = 0; i < acceptedMimeTypes.len; ++i) { QString acceptedMimeTypes_arr_i_QString = QString::fromUtf8(acceptedMimeTypes_arr[i].data, acceptedMimeTypes_arr[i].len); acceptedMimeTypes_QList.push_back(acceptedMimeTypes_arr_i_QString); } - QStringList _ret = static_cast(self)->QWebEnginePage::chooseFiles(static_cast(mode), oldFiles_QList, acceptedMimeTypes_QList); + QList _ret = static_cast(self)->QWebEnginePage::chooseFiles(static_cast(mode), oldFiles_QList, acceptedMimeTypes_QList); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -1305,7 +1301,7 @@ struct miqt_array /* of struct miqt_string */ QWebEnginePage_virtualbase_choose _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebenginepage.go b/qt6/webengine/gen_qwebenginepage.go index 1ccad0c573..ac228589fd 100644 --- a/qt6/webengine/gen_qwebenginepage.go +++ b/qt6/webengine/gen_qwebenginepage.go @@ -270,10 +270,6 @@ func (this *QWebEnginePage) Event(param1 *qt6.QEvent) bool { return (bool)(C.QWebEnginePage_event(this.h, (*C.QEvent)(param1.UnsafePointer()))) } -func (this *QWebEnginePage) SetFeaturePermission(securityOrigin *qt6.QUrl, feature QWebEnginePage__Feature, policy QWebEnginePage__PermissionPolicy) { - C.QWebEnginePage_setFeaturePermission(this.h, (*C.QUrl)(securityOrigin.UnsafePointer()), (C.int)(feature), (C.int)(policy)) -} - func (this *QWebEnginePage) IsLoading() bool { return (bool)(C.QWebEnginePage_isLoading(this.h)) } diff --git a/qt6/webengine/gen_qwebenginepage.h b/qt6/webengine/gen_qwebenginepage.h index 17ed3fe8b3..87a7f5928c 100644 --- a/qt6/webengine/gen_qwebenginepage.h +++ b/qt6/webengine/gen_qwebenginepage.h @@ -100,7 +100,6 @@ QAction* QWebEnginePage_action(const QWebEnginePage* self, int action); void QWebEnginePage_triggerAction(QWebEnginePage* self, int action, bool checked); void QWebEnginePage_replaceMisspelledWord(QWebEnginePage* self, struct miqt_string replacement); bool QWebEnginePage_event(QWebEnginePage* self, QEvent* param1); -void QWebEnginePage_setFeaturePermission(QWebEnginePage* self, QUrl* securityOrigin, int feature, int policy); bool QWebEnginePage_isLoading(const QWebEnginePage* self); void QWebEnginePage_load(QWebEnginePage* self, QUrl* url); void QWebEnginePage_loadWithRequest(QWebEnginePage* self, QWebEngineHttpRequest* request); diff --git a/qt6/webengine/gen_qwebengineprofile.cpp b/qt6/webengine/gen_qwebengineprofile.cpp index 175404ea00..613d0ae01f 100644 --- a/qt6/webengine/gen_qwebengineprofile.cpp +++ b/qt6/webengine/gen_qwebengineprofile.cpp @@ -384,7 +384,7 @@ void QWebEngineProfile_clearHttpCache(QWebEngineProfile* self) { } void QWebEngineProfile_setSpellCheckLanguages(QWebEngineProfile* self, struct miqt_array /* of struct miqt_string */ languages) { - QStringList languages_QList; + QList languages_QList; languages_QList.reserve(languages.len); struct miqt_string* languages_arr = static_cast(languages.data); for(size_t i = 0; i < languages.len; ++i) { @@ -395,10 +395,10 @@ void QWebEngineProfile_setSpellCheckLanguages(QWebEngineProfile* self, struct mi } struct miqt_array /* of struct miqt_string */ QWebEngineProfile_spellCheckLanguages(const QWebEngineProfile* self) { - QStringList _ret = self->spellCheckLanguages(); + QList _ret = self->spellCheckLanguages(); // Convert QList<> from C++ memory to manually-managed C memory - struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + struct miqt_string* _arr = static_cast(malloc(sizeof(struct miqt_string) * _ret.size())); + for (size_t i = 0, e = _ret.size(); 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(); @@ -409,7 +409,7 @@ struct miqt_array /* of struct miqt_string */ QWebEngineProfile_spellCheckLangu _arr[i] = _lv_ms; } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } diff --git a/qt6/webengine/gen_qwebenginescriptcollection.cpp b/qt6/webengine/gen_qwebenginescriptcollection.cpp index aea588fe9a..353c12ab32 100644 --- a/qt6/webengine/gen_qwebenginescriptcollection.cpp +++ b/qt6/webengine/gen_qwebenginescriptcollection.cpp @@ -31,12 +31,12 @@ struct miqt_array /* of QWebEngineScript* */ QWebEngineScriptCollection_find(co QString name_QString = QString::fromUtf8(name.data, name.len); QList _ret = self->find(name_QString); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineScript(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; } @@ -66,12 +66,12 @@ void QWebEngineScriptCollection_clear(QWebEngineScriptCollection* self) { struct miqt_array /* of QWebEngineScript* */ QWebEngineScriptCollection_toList(const QWebEngineScriptCollection* self) { QList _ret = self->toList(); // Convert QList<> from C++ memory to manually-managed C memory - QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.length())); - for (size_t i = 0, e = _ret.length(); i < e; ++i) { + QWebEngineScript** _arr = static_cast(malloc(sizeof(QWebEngineScript*) * _ret.size())); + for (size_t i = 0, e = _ret.size(); i < e; ++i) { _arr[i] = new QWebEngineScript(_ret[i]); } struct miqt_array _out; - _out.len = _ret.length(); + _out.len = _ret.size(); _out.data = static_cast(_arr); return _out; }