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

Merge 3d0e923e329935a5af1c2638bc3c33ea2d61594f into 5ac6083a3d1b1bb774d23861c30daf8b3276dbee

Browse Source
This commit is contained in:
mappu 2025-05-24 09:34:31 +02:00 committed by GitHub
commit f3c6033723
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
28 changed files with 18187 additions and 86 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
cmd/genbindings/clang2il.go
View File

@ -193,6 +193,11 @@ const (
VsPrivate = 3
)
type ClassParentName struct {
Unqualified string
Qualified string
}
// processClassType parses a single C++ class definition into our intermediate format.
func processClassType(node map[string]interface{}, addNamePrefix string) (CppClass, error) {
var ret CppClass
@ -265,7 +270,15 @@ 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 {
ret.DirectInherits = append(ret.DirectInherits, qualType)
// The name that we're inheriting may- or may not- be
// Even `qualType` doesn't necessarily figure this out
// for us
// Stash both the qualified + unqualified names for later
// resolution
ret.DirectInherits = append(ret.DirectInherits, ClassParentName{
Qualified: addNamePrefix + qualType,
Unqualified: qualType,
})
}
}
}

142
cmd/genbindings/config-allowlist.go
View File

@ -14,49 +14,58 @@ func InsertTypedefs(qt6 bool) {
}
// QString is deleted from this binding
KnownTypedefs["QStringList"] = lookupResultTypedef{pp, CppTypedef{"QStringList", parseSingleTypeString("QList<QString>")}}
KnownTypedefs["QStringList"] = lookupResultTypedef{pp, "", CppTypedef{"QStringList", parseSingleTypeString("QList<QString>")}}
// FIXME this isn't picked up automatically because QFile inherits QFileDevice and the name refers to its parent class
KnownTypedefs["QFile::FileTime"] = lookupResultTypedef{pp, CppTypedef{"QFile::FileTime", parseSingleTypeString("QFileDevice::FileTime")}}
KnownTypedefs["QFile::FileTime"] = lookupResultTypedef{pp, "", CppTypedef{"QFile::FileTime", parseSingleTypeString("QFileDevice::FileTime")}}
if !qt6 {
// n.b. Qt 5 only
KnownTypedefs["QLineF::IntersectionType"] = lookupResultTypedef{pp, CppTypedef{"QLineF::IntersectionType", parseSingleTypeString("QLineF::IntersectType")}}
KnownTypedefs["QLineF::IntersectionType"] = lookupResultTypedef{pp, "", CppTypedef{"QLineF::IntersectionType", parseSingleTypeString("QLineF::IntersectType")}}
} else {
// Must be removed for Qt 6
}
// Not sure the reason for this one
KnownTypedefs["QSocketDescriptor::DescriptorType"] = lookupResultTypedef{pp, CppTypedef{"QSocketDescriptor::DescriptorType", parseSingleTypeString("QSocketNotifier::Type")}}
KnownTypedefs["QSocketDescriptor::DescriptorType"] = lookupResultTypedef{pp, "", CppTypedef{"QSocketDescriptor::DescriptorType", parseSingleTypeString("QSocketNotifier::Type")}}
// QFile doesn't see QFileDevice parent class enum
KnownTypedefs["QFile::Permissions"] = lookupResultTypedef{pp, CppTypedef{"QFile::Permissions", parseSingleTypeString("QFileDevice::Permissions")}}
KnownTypedefs["QFileDevice::Permissions"] = lookupResultTypedef{pp, CppTypedef{"QFile::Permissions", parseSingleTypeString("QFlags<QFileDevice::Permission>")}}
KnownTypedefs["QIODevice::OpenMode"] = lookupResultTypedef{pp, CppTypedef{"QIODevice::OpenMode", parseSingleTypeString("QIODeviceBase::OpenMode")}}
KnownTypedefs["QFile::Permissions"] = lookupResultTypedef{pp, "", CppTypedef{"QFile::Permissions", parseSingleTypeString("QFileDevice::Permissions")}}
KnownTypedefs["QFileDevice::Permissions"] = lookupResultTypedef{pp, "", CppTypedef{"QFile::Permissions", parseSingleTypeString("QFlags<QFileDevice::Permission>")}}
KnownTypedefs["QIODevice::OpenMode"] = lookupResultTypedef{pp, "", CppTypedef{"QIODevice::OpenMode", parseSingleTypeString("QIODeviceBase::OpenMode")}}
// Qt 5 WebKit - use of an empty enum (should be possible to support?)
KnownEnums["QWebPluginFactory::Extension"] = lookupResultEnum{"qt/webkit", CppEnum{
KnownEnums["QWebPluginFactory::Extension"] = lookupResultEnum{"qt/webkit", "", CppEnum{
EnumName: "QWebPluginFactory::Extension",
UnderlyingType: CppParameter{
ParameterType: "int",
},
}}
// Qt 5 qtermwidget
// The nested namespaces need better name resolution handling
/*
KnownTypedefs["KeyboardTranslator::Command"] = lookupResultTypedef{"qt/qtermwidget", CppTypedef{"KeyboardTranslator::Command", parseSingleTypeString("Konsole::KeyboardTranslator::Command")}}
KnownTypedefs["KeyboardTranslator::Entry"] = lookupResultTypedef{"qt/qtermwidget", CppTypedef{"KeyboardTranslator::Entry", parseSingleTypeString("Konsole::KeyboardTranslator::Entry")}}
KnownTypedefs["RegExpFilter::HotSpot"] = lookupResultTypedef{"qt/qtermwidget", CppTypedef{"RegExpFilter::HotSpot", parseSingleTypeString("Konsole::RegExpFilter::HotSpot")}}
KnownTypedefs["Filter::HotSpot"] = lookupResultTypedef{"qt/qtermwidget", CppTypedef{"Filter::HotSpot", parseSingleTypeString("Konsole::Filter::HotSpot")}}
*/
if qt6 {
// Qt 6 QVariant helper types - needs investigation
KnownTypedefs["QVariantHash"] = lookupResultTypedef{"qt6", CppTypedef{"QVariantHash", parseSingleTypeString("QHash<QString,QVariant>")}}
KnownTypedefs["QVariantList"] = lookupResultTypedef{"qt6", CppTypedef{"QVariantList", parseSingleTypeString("QList<QVariant>")}}
KnownTypedefs["QVariantMap"] = lookupResultTypedef{"qt6", CppTypedef{"QVariantMap", parseSingleTypeString("QMap<QString,QVariant>")}}
KnownTypedefs["QVariantHash"] = lookupResultTypedef{"qt6", "", CppTypedef{"QVariantHash", parseSingleTypeString("QHash<QString,QVariant>")}}
KnownTypedefs["QVariantList"] = lookupResultTypedef{"qt6", "", CppTypedef{"QVariantList", parseSingleTypeString("QList<QVariant>")}}
KnownTypedefs["QVariantMap"] = lookupResultTypedef{"qt6", "", CppTypedef{"QVariantMap", parseSingleTypeString("QMap<QString,QVariant>")}}
// Qt 6 renamed the enum to LibraryPath, but left some uses of LibraryLocation with a typedef
// We don't find the typedef - needs investigation
// ONLY add this on Qt 6 builds, breaks Qt 5
KnownTypedefs["QLibraryInfo::LibraryLocation"] = lookupResultTypedef{"qt6", CppTypedef{"QLibraryInfo::LibraryLocation", parseSingleTypeString("QLibraryInfo::LibraryPath")}}
KnownTypedefs["QLibraryInfo::LibraryLocation"] = lookupResultTypedef{"qt6", "", CppTypedef{"QLibraryInfo::LibraryLocation", parseSingleTypeString("QLibraryInfo::LibraryPath")}}
// Enums
// QSysInfo.h is being truncated and not finding any content
KnownEnums["QSysInfo::Endian"] = lookupResultEnum{"qt6", CppEnum{
KnownEnums["QSysInfo::Endian"] = lookupResultEnum{"qt6", "", CppEnum{
EnumName: "QSysInfo::Endian",
UnderlyingType: CppParameter{
ParameterType: "int",
@ -159,6 +168,8 @@ func ImportHeaderForClass(className string) bool {
"QText", // e.g. qtextcursor.h
"QVLABaseBase", // e.g. Qt 6 qvarlengtharray.h
"QAdoptSharedDataTag", // Qt 6 qshareddata.h
// "QTermWidget", // Qt 5 qtermwidget. Does not make nice <className> file helpers
// "QTermWidgetInterface", // Qt 5 qtermwidget. Does not make nice <className> file helpers
"____last____":
return false
}
@ -387,6 +398,14 @@ func AllowMethod(className string, mm CppMethod) error {
return ErrTooComplex // e.g. QSize::rheight()
}
// Qt 5 libqtermwidget. This works and is present but the namespace lookups are messed up
if className == "KeyboardTranslator::Command" ||
className == "KeyboardTranslator::Entry" ||
className == "RegExpFilter::HotSpot" ||
className == "Filter::HotSpot" {
return ErrTooComplex
}
return nil // OK, allow
}
@ -580,50 +599,59 @@ func AllowType(p CppParameter, isReturnType bool) error {
"QPolygon", "QPolygonF", // QPolygon extends a template type
"QGenericMatrix", "QMatrix3x3", // extends a template type
"QLatin1String", "QStringView", // e.g. QColor constructors and QColor::SetNamedColor() overloads. These are usually optional alternatives to QString
"QLatin1StringView", // Qt 6 - used in qanystringview
"QUtf8StringView", // Qt 6 - used in qdebug
"QStringRef", // e.g. QLocale::toLongLong and similar overloads. As above
"qfloat16", // e.g. QDataStream - there is no such half-float type in C or Go
"char16_t", // e.g. QChar() constructor overload, just unnecessary
"char32_t", // e.g. QDebug().operator<< overload, unnecessary
"wchar_t", // e.g. qstringview.h overloads, unnecessary
"FILE", // e.g. qfile.h constructors
"sockaddr", // Qt network Qhostaddress. Should be possible to make this work but may be platform-specific
"qInternalCallback", // e.g. qnamespace.h
"QGraphicsEffectSource", // e.g. used by qgraphicseffect.h, but the definition is in ????
"QXmlStreamEntityDeclarations", // e.g. qxmlstream.h. The class definition was blacklisted for ???? reason so don't allow it as a parameter either
"QXmlStreamNamespaceDeclarations", // e.g. qxmlstream.h. As above
"QXmlStreamNotationDeclarations", // e.g. qxmlstream.h. As above
"QXmlStreamAttributes", // e.g. qxmlstream.h
"LineLayout::ValidLevel", // ..
"QtMsgType", // e.g. qdebug.h TODO Defined in qlogging.h, but omitted because it's predefined in qglobal.h, and our clangexec is too agressive
"QTextStreamFunction", // e.g. qdebug.h
"QFactoryInterface", // qfactoryinterface.h
"QTextEngine", // used by qtextlayout.h, also blocked in ImportHeaderForClass above
"QVulkanInstance", // e.g. qwindow.h. Not tackling vulkan yet
"QPlatformNativeInterface", // e.g. QGuiApplication::platformNativeInterface(). Private type, could probably expose as uintptr. n.b. Changes in Qt6
"QPlatformBackingStore", // e.g. qbackingstore.h, as below
"QPlatformMenuBar", // e.g. qfutureinterface.h, as below
"QPlatformOffscreenSurface", // e.g. qoffscreensurface.h, as below
"QPlatformPixmap", // e.g. qpixmap.h. as below
"QPlatformScreen", // e.g. qscreen.h. as below
"QPlatformWindow", // e.g. qwindow.h, as below
"QPlatformSurface", // e.g. qsurface.h. as below
"QPlatformMenu", // e.g. QMenu_PlatformMenu. Defined in the QPA, could probably expose as uintptr
"QPlatformMediaCaptureSession", // Qt 6 Multimedia qmediacapturesession.h
"QPlatformMediaRecorder", // Qt 6 Multimedia qmediarecorder.h
"QPlatformVideoSink", // Qt 6 Multimedia qvideosink.h
"QTextDocument::ResourceProvider", // Qt 6 typedef for unsupported std::function<QVariant(const QUrl&)>
"QTransform::Affine", // Qt 6 qtransform.h - public method returning private type
"QAbstractAudioBuffer", // Qt 5 Multimedia, this is a private/internal type only
"QAbstractVideoBuffer", // Works in Qt 5, but in Qt 6 Multimedia this type is used in qvideoframe.h but is not defined anywhere (it was later added in Qt 6.8)
"QRhi", // Qt 6 unstable types, used in Multimedia
"QPostEventList", // Qt QCoreApplication: private headers required
"QMetaCallEvent", // ..
"QPostEvent", // ..
"QWebFrameAdapter", // Qt 5 Webkit: Used by e.g. qwebframe.h but never defined anywhere
"QWebPageAdapter", // ...
"QQmlWebChannelAttached", // Qt 5 qqmlwebchannel.h. Need to add QML support for this to work
"QLatin1StringView", // Qt 6 - used in qanystringview
"QUtf8StringView", // Qt 6 - used in qdebug
"QStringRef", // e.g. QLocale::toLongLong and similar overloads. As above
"qfloat16", // e.g. QDataStream - there is no such half-float type in C or Go
"char16_t", // e.g. QChar() constructor overload, just unnecessary
"char32_t", // e.g. QDebug().operator<< overload, unnecessary
"wchar_t", // e.g. qstringview.h overloads, unnecessary
"FILE", // e.g. qfile.h constructors
"sockaddr", // Qt network Qhostaddress. Should be possible to make this work but may be platform-specific
"qInternalCallback", // e.g. qnamespace.h
"QGraphicsEffectSource", // e.g. used by qgraphicseffect.h, but the definition is in ????
"QXmlStreamEntityDeclarations", // e.g. qxmlstream.h. The class definition was blacklisted for ???? reason so don't allow it as a parameter either
"QXmlStreamNamespaceDeclarations", // e.g. qxmlstream.h. As above
"QXmlStreamNotationDeclarations", // e.g. qxmlstream.h. As above
"QXmlStreamAttributes", // e.g. qxmlstream.h
"LineLayout::ValidLevel", // ..
"QtMsgType", // e.g. qdebug.h TODO Defined in qlogging.h, but omitted because it's predefined in qglobal.h, and our clangexec is too agressive
"QTextStreamFunction", // e.g. qdebug.h
"QFactoryInterface", // qfactoryinterface.h
"QTextEngine", // used by qtextlayout.h, also blocked in ImportHeaderForClass above
"QVulkanInstance", // e.g. qwindow.h. Not tackling vulkan yet
"QPlatformNativeInterface", // e.g. QGuiApplication::platformNativeInterface(). Private type, could probably expose as uintptr. n.b. Changes in Qt6
"QPlatformBackingStore", // e.g. qbackingstore.h, as below
"QPlatformMenuBar", // e.g. qfutureinterface.h, as below
"QPlatformOffscreenSurface", // e.g. qoffscreensurface.h, as below
"QPlatformPixmap", // e.g. qpixmap.h. as below
"QPlatformScreen", // e.g. qscreen.h. as below
"QPlatformWindow", // e.g. qwindow.h, as below
"QPlatformSurface", // e.g. qsurface.h. as below
"QPlatformMenu", // e.g. QMenu_PlatformMenu. Defined in the QPA, could probably expose as uintptr
"QPlatformMediaCaptureSession", // Qt 6 Multimedia qmediacapturesession.h
"QPlatformMediaRecorder", // Qt 6 Multimedia qmediarecorder.h
"QPlatformVideoSink", // Qt 6 Multimedia qvideosink.h
"QTextDocument::ResourceProvider", // Qt 6 typedef for unsupported std::function<QVariant(const QUrl&)>
"QTransform::Affine", // Qt 6 qtransform.h - public method returning private type
"QAbstractAudioBuffer", // Qt 5 Multimedia, this is a private/internal type only
"QAbstractVideoBuffer", // Works in Qt 5, but in Qt 6 Multimedia this type is used in qvideoframe.h but is not defined anywhere (it was later added in Qt 6.8)
"QRhi", // Qt 6 unstable types, used in Multimedia
"QPostEventList", // Qt QCoreApplication: private headers required
"QMetaCallEvent", // ..
"QPostEvent", // ..
"QWebFrameAdapter", // Qt 5 Webkit: Used by e.g. qwebframe.h but never defined anywhere
"QWebPageAdapter", // ...
"QQmlWebChannelAttached", // Qt 5 qqmlwebchannel.h. Need to add QML support for this to work
"Konsole::ScreenWindow", // Qt 5 libqtermwidget. This is an internal class, it's in the Git repo but not in the Debian package
"Konsole::HistoryType", // Qt 5 libqtermwidget. This is an internal class, it's in the Git repo but not in the Debian package
"Konsole::TerminalCharacterDecoder", // Qt 5 libqtermwidget. This is an internal class, it's in the Git repo but not in the Debian package
"Konsole::Character", // Qt 5 libqtermwidget. This is an internal class, it's in the Git repo but not in the Debian package
"KeyboardTranslator::Command", // Qt 5 libqtermwidget. This works and is present but the namespace lookups are messed up
"KeyboardTranslator::Entry", // Qt 5 libqtermwidget. This works and is present but the namespace lookups are messed up
"RegExpFilter::HotSpot", // Qt 5 libqtermwidget. This works and is present but the namespace lookups are messed up
"Filter::HotSpot", // Qt 5 libqtermwidget. This works and is present but the namespace lookups are messed up
"____last____":
return ErrTooComplex
}

12
cmd/genbindings/config-libraries.go
View File

@ -242,6 +242,18 @@ func ProcessLibraries(clangBin, outDir, extraLibsDir string) {
(&clangMatchUnderPath{filepath.Join(extraLibsDir, "scintilla")}).Match,
)
generate(
"qt-restricted-extras/qtermwidget",
[]string{
"/usr/include/qtermwidget5",
},
AllowAllHeaders,
clangBin,
pkgConfigCflags("qtermwidget5"),
outDir,
ClangMatchSameHeaderDefinitionOnly,
)
// FLUSH all known typedefs / ...
flushKnownTypes()

24
cmd/genbindings/emitcabi.go
View File

@ -925,6 +925,8 @@ func emitParametersCabiConstructor(c *CppClass, ctor *CppMethod) string {
func emitBindingCpp(src *CppParsedHeader, filename string) (string, error) {
ret := strings.Builder{}
importedHeaders := make(map[string]struct{})
for _, ref := range getReferencedTypes(src) {
if ref == "QString" {
@ -943,7 +945,29 @@ func emitBindingCpp(src *CppParsedHeader, filename string) (string, error) {
continue
}
if cinfo, ok := KnownClassnames[ref]; ok && len(cinfo.HeaderFile) > 0 {
// We know exactly which header file we actually found it in
// For core Qt classes, #include the <className> directly, as Qt
// has helper mini-headers for almost all types which work even
// if the headers are restructured in different Qt versions
// But for some subpackages they don't offer this
if cinfo.PackageName == "qt/qtermwidget" {
// Wanted
ref = cinfo.HeaderFile
} else {
// Not wanted
}
}
// The transform above can cause duplicate imports. Only import them once
// Headers usually have #pragma once or equivalent, but this is courteous
if _, ok := importedHeaders[ref]; ok {
continue
}
ret.WriteString(`#include <` + ref + ">\n")
importedHeaders[ref] = struct{}{}
}
ret.WriteString(`#include <` + filename + ">\n")

13
cmd/genbindings/emitgo.go
View File

@ -800,18 +800,15 @@ import "C"
// Embed all inherited types to directly allow calling inherited methods
// Only include the direct inherits; the recursive inherits will exist
// on these types already
for _, base := range c.DirectInherits {
for _, parentClass := range c.DirectInheritClassInfo() {
if strings.HasPrefix(base, `QList<`) {
ret.WriteString("/* Also inherits unprojectable " + base + " */\n")
} else if pkg, ok := KnownClassnames[base]; ok && pkg.PackageName != gfs.currentPackageName {
if parentClass.PackageName != gfs.currentPackageName {
// Cross-package parent class
ret.WriteString("*" + path.Base(pkg.PackageName) + "." + cabiClassName(base) + "\n")
gfs.imports[importPathForQtPackage(pkg.PackageName)] = struct{}{}
ret.WriteString("*" + path.Base(parentClass.PackageName) + "." + cabiClassName(parentClass.Class.ClassName) + "\n")
gfs.imports[importPathForQtPackage(parentClass.PackageName)] = struct{}{}
} else {
// Same-package parent class
ret.WriteString("*" + cabiClassName(base) + "\n")
ret.WriteString("*" + cabiClassName(parentClass.Class.ClassName) + "\n")
}
}

46
cmd/genbindings/intermediate.go
View File

@ -1,6 +1,7 @@
package main
import (
"fmt"
"log"
"regexp"
"strings"
@ -402,8 +403,8 @@ func (e CppEnum) ShortEnumName() string {
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
Ctors []CppMethod // only use the parameters
DirectInherits []ClassParentName // other class names. This only includes direct inheritance - use AllInherits() to find recursive inheritance
Methods []CppMethod
Props []CppProperty
CanDelete bool
@ -622,18 +623,41 @@ func (c *CppClass) AllInheritsClassInfo() []lookupResultClass {
func (c *CppClass) DirectInheritClassInfo() []lookupResultClass {
var ret []lookupResultClass
nextInherit:
for _, inh := range c.DirectInherits {
cinfo, ok := KnownClassnames[inh]
if !ok {
if !AllowInheritedParent(inh) {
// OK, allow this one to slip through
continue
} else {
panic("Class " + c.ClassName + " inherits from unknown class " + inh)
}
// TODO expand to cover all unprojected container types?
if strings.HasPrefix(inh.Unqualified, `QList<`) {
continue
}
ret = append(ret, cinfo)
checkParents := []string{
inh.Qualified,
inh.Unqualified,
}
if nparts := strings.Split(inh.Qualified, `::`); len(nparts) == 4 {
// qtermwidget5: finds `Konsole::RegExpFilter::Filter::HotSpot` but
// needs to match Konsole (namespace) :: Filter::HotSpot
checkParents = append(checkParents, nparts[0]+`::`+nparts[2]+`::`+nparts[3])
}
for _, checkParent := range checkParents {
cinfo, ok := KnownClassnames[checkParent]
if ok {
ret = append(ret, cinfo)
continue nextInherit
}
if !AllowInheritedParent(checkParent) {
// OK, allow this one to slip through
continue nextInherit
}
// Name didn't match
}
// None of the names matched
panic(fmt.Sprintf("Class %q inherits from unknown class (tried: %v)", c.ClassName, checkParents))
}
return ret

2
cmd/genbindings/main.go
View File

@ -166,7 +166,7 @@ func generate(packageName string, srcDirs []string, allowHeaderFn func(string) b
atr.Process(parsed)
// Update global state tracker (AFTER astTransformChildClasses)
addKnownTypes(packageName, parsed)
addKnownTypes(packageName, filepath.Base(inputHeader), parsed)
processHeaders = append(processHeaders, parsed)
}

11
cmd/genbindings/statetracker.go
View File

@ -2,16 +2,19 @@ package main
type lookupResultClass struct {
PackageName string
HeaderFile string
Class CppClass
}
type lookupResultTypedef struct {
PackageName string
HeaderFile string
Typedef CppTypedef
}
type lookupResultEnum struct {
PackageName string
HeaderFile string
Enum CppEnum
}
@ -27,14 +30,14 @@ func flushKnownTypes() {
KnownEnums = make(map[string]lookupResultEnum)
}
func addKnownTypes(packageName string, parsed *CppParsedHeader) {
func addKnownTypes(packageName, headerFile string, parsed *CppParsedHeader) {
for _, c := range parsed.Classes {
KnownClassnames[c.ClassName] = lookupResultClass{packageName, c /* copy */}
KnownClassnames[c.ClassName] = lookupResultClass{packageName, headerFile, c /* copy */}
}
for _, td := range parsed.Typedefs {
KnownTypedefs[td.Alias] = lookupResultTypedef{packageName, td /* copy */}
KnownTypedefs[td.Alias] = lookupResultTypedef{packageName, headerFile, td /* copy */}
}
for _, en := range parsed.Enums {
KnownEnums[en.EnumName] = lookupResultEnum{packageName, en /* copy */}
KnownEnums[en.EnumName] = lookupResultEnum{packageName, headerFile, en /* copy */}
}
}

2
docker/genbindings.Dockerfile
View File

@ -19,6 +19,8 @@ RUN DEBIAN_FRONTEND=noninteractive apt-get update && \
qt6-webengine-dev \
libqscintilla2-qt5-dev \
libqscintilla2-qt6-dev \
libqtermwidget5-1-dev \
libutf8proc-dev \
clang \
git \
ca-certificates \

19
examples/libraries/restricted-extras-qtermwidget/main.go Normal file
View File

@ -0,0 +1,19 @@
package main
import (
"os"
"github.com/mappu/miqt/qt"
"github.com/mappu/miqt/qt-restricted-extras/qtermwidget"
)
func main() {
qt.NewQApplication(os.Args)
term := qtermwidget.NewQTermWidget3()
term.SetFixedSize2(640, 480)
term.Show()
qt.QApplication_Exec()
}

6
qt-restricted-extras/qtermwidget/cflags.go Normal file
View File

@ -0,0 +1,6 @@
package qtermwidget
/*
#cgo pkg-config: qtermwidget5
*/
import "C"

1096
qt-restricted-extras/qtermwidget/gen_Emulation.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1129
qt-restricted-extras/qtermwidget/gen_Emulation.go Normal file
View File

File diff suppressed because it is too large Load Diff

157
qt-restricted-extras/qtermwidget/gen_Emulation.h Normal file
View File

@ -0,0 +1,157 @@
#pragma once
#ifndef MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_EMULATION_H
#define MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_EMULATION_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__Emulation)
typedef Konsole::Emulation Konsole__Emulation;
#else
class Konsole__Emulation;
#endif
class QChildEvent;
class QEvent;
class QKeyEvent;
class QMetaMethod;
class QMetaObject;
class QObject;
class QSize;
class QTextCodec;
class QTimerEvent;
#else
typedef struct Konsole__Emulation Konsole__Emulation;
typedef struct QChildEvent QChildEvent;
typedef struct QEvent QEvent;
typedef struct QKeyEvent QKeyEvent;
typedef struct QMetaMethod QMetaMethod;
typedef struct QMetaObject QMetaObject;
typedef struct QObject QObject;
typedef struct QSize QSize;
typedef struct QTextCodec QTextCodec;
typedef struct QTimerEvent QTimerEvent;
#endif
Konsole__Emulation* Konsole__Emulation_new();
void Konsole__Emulation_virtbase(Konsole__Emulation* src, QObject** outptr_QObject);
QMetaObject* Konsole__Emulation_metaObject(const Konsole__Emulation* self);
void* Konsole__Emulation_metacast(Konsole__Emulation* self, const char* param1);
struct miqt_string Konsole__Emulation_tr(const char* s);
struct miqt_string Konsole__Emulation_trUtf8(const char* s);
QSize* Konsole__Emulation_imageSize(const Konsole__Emulation* self);
int Konsole__Emulation_lineCount(const Konsole__Emulation* self);
void Konsole__Emulation_clearHistory(Konsole__Emulation* self);
QTextCodec* Konsole__Emulation_codec(const Konsole__Emulation* self);
void Konsole__Emulation_setCodec(Konsole__Emulation* self, QTextCodec* codec);
bool Konsole__Emulation_utf8(const Konsole__Emulation* self);
char Konsole__Emulation_eraseChar(const Konsole__Emulation* self);
void Konsole__Emulation_setKeyBindings(Konsole__Emulation* self, struct miqt_string name);
struct miqt_string Konsole__Emulation_keyBindings(const Konsole__Emulation* self);
void Konsole__Emulation_clearEntireScreen(Konsole__Emulation* self);
void Konsole__Emulation_reset(Konsole__Emulation* self);
bool Konsole__Emulation_programUsesMouse(const Konsole__Emulation* self);
bool Konsole__Emulation_programBracketedPasteMode(const Konsole__Emulation* self);
void Konsole__Emulation_setImageSize(Konsole__Emulation* self, int lines, int columns);
void Konsole__Emulation_sendText(Konsole__Emulation* self, struct miqt_string text);
void Konsole__Emulation_sendKeyEvent(Konsole__Emulation* self, QKeyEvent* param1, bool fromPaste);
void Konsole__Emulation_sendMouseEvent(Konsole__Emulation* self, int buttons, int column, int line, int eventType);
void Konsole__Emulation_sendString(Konsole__Emulation* self, const char* string, int length);
void Konsole__Emulation_receiveData(Konsole__Emulation* self, const char* buffer, int len);
void Konsole__Emulation_sendData(Konsole__Emulation* self, const char* data, int len);
void Konsole__Emulation_connect_sendData(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_lockPtyRequest(Konsole__Emulation* self, bool suspend);
void Konsole__Emulation_connect_lockPtyRequest(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_useUtf8Request(Konsole__Emulation* self, bool param1);
void Konsole__Emulation_connect_useUtf8Request(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_stateSet(Konsole__Emulation* self, int state);
void Konsole__Emulation_connect_stateSet(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_zmodemDetected(Konsole__Emulation* self);
void Konsole__Emulation_connect_zmodemDetected(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_changeTabTextColorRequest(Konsole__Emulation* self, int color);
void Konsole__Emulation_connect_changeTabTextColorRequest(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_programUsesMouseChanged(Konsole__Emulation* self, bool usesMouse);
void Konsole__Emulation_connect_programUsesMouseChanged(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_programBracketedPasteModeChanged(Konsole__Emulation* self, bool bracketedPasteMode);
void Konsole__Emulation_connect_programBracketedPasteModeChanged(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_outputChanged(Konsole__Emulation* self);
void Konsole__Emulation_connect_outputChanged(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_titleChanged(Konsole__Emulation* self, int title, struct miqt_string newTitle);
void Konsole__Emulation_connect_titleChanged(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_imageSizeChanged(Konsole__Emulation* self, int lineCount, int columnCount);
void Konsole__Emulation_connect_imageSizeChanged(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_imageSizeInitialized(Konsole__Emulation* self);
void Konsole__Emulation_connect_imageSizeInitialized(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_imageResizeRequest(Konsole__Emulation* self, QSize* sizz);
void Konsole__Emulation_connect_imageResizeRequest(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_profileChangeCommandReceived(Konsole__Emulation* self, struct miqt_string text);
void Konsole__Emulation_connect_profileChangeCommandReceived(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_flowControlKeyPressed(Konsole__Emulation* self, bool suspendKeyPressed);
void Konsole__Emulation_connect_flowControlKeyPressed(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_cursorChanged(Konsole__Emulation* self, int cursorShape, bool blinkingCursorEnabled);
void Konsole__Emulation_connect_cursorChanged(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_outputFromKeypressEvent(Konsole__Emulation* self);
void Konsole__Emulation_connect_outputFromKeypressEvent(Konsole__Emulation* self, intptr_t slot);
void Konsole__Emulation_setMode(Konsole__Emulation* self, int mode);
void Konsole__Emulation_resetMode(Konsole__Emulation* self, int mode);
struct miqt_string Konsole__Emulation_tr2(const char* s, const char* c);
struct miqt_string Konsole__Emulation_tr3(const char* s, const char* c, int n);
struct miqt_string Konsole__Emulation_trUtf82(const char* s, const char* c);
struct miqt_string Konsole__Emulation_trUtf83(const char* s, const char* c, int n);
bool Konsole__Emulation_override_virtual_eraseChar(void* self, intptr_t slot);
char Konsole__Emulation_virtualbase_eraseChar(const void* self);
bool Konsole__Emulation_override_virtual_clearEntireScreen(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_clearEntireScreen(void* self);
bool Konsole__Emulation_override_virtual_reset(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_reset(void* self);
bool Konsole__Emulation_override_virtual_setImageSize(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_setImageSize(void* self, int lines, int columns);
bool Konsole__Emulation_override_virtual_sendText(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_sendText(void* self, struct miqt_string text);
bool Konsole__Emulation_override_virtual_sendKeyEvent(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_sendKeyEvent(void* self, QKeyEvent* param1, bool fromPaste);
bool Konsole__Emulation_override_virtual_sendMouseEvent(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_sendMouseEvent(void* self, int buttons, int column, int line, int eventType);
bool Konsole__Emulation_override_virtual_sendString(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_sendString(void* self, const char* string, int length);
bool Konsole__Emulation_override_virtual_setMode(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_setMode(void* self, int mode);
bool Konsole__Emulation_override_virtual_resetMode(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_resetMode(void* self, int mode);
bool Konsole__Emulation_override_virtual_event(void* self, intptr_t slot);
bool Konsole__Emulation_virtualbase_event(void* self, QEvent* event);
bool Konsole__Emulation_override_virtual_eventFilter(void* self, intptr_t slot);
bool Konsole__Emulation_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
bool Konsole__Emulation_override_virtual_timerEvent(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_timerEvent(void* self, QTimerEvent* event);
bool Konsole__Emulation_override_virtual_childEvent(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_childEvent(void* self, QChildEvent* event);
bool Konsole__Emulation_override_virtual_customEvent(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_customEvent(void* self, QEvent* event);
bool Konsole__Emulation_override_virtual_connectNotify(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_connectNotify(void* self, QMetaMethod* signal);
bool Konsole__Emulation_override_virtual_disconnectNotify(void* self, intptr_t slot);
void Konsole__Emulation_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
void Konsole__Emulation_protectedbase_setScreen(bool* _dynamic_cast_ok, void* self, int index);
void Konsole__Emulation_protectedbase_setCodecWithCodec(bool* _dynamic_cast_ok, void* self, int codec);
void Konsole__Emulation_protectedbase_bufferedUpdate(bool* _dynamic_cast_ok, void* self);
QObject* Konsole__Emulation_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
int Konsole__Emulation_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
int Konsole__Emulation_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
bool Konsole__Emulation_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
void Konsole__Emulation_delete(Konsole__Emulation* self);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

2051
qt-restricted-extras/qtermwidget/gen_Filter.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

2054
qt-restricted-extras/qtermwidget/gen_Filter.go Normal file
View File

File diff suppressed because it is too large Load Diff

267
qt-restricted-extras/qtermwidget/gen_Filter.h Normal file
View File

@ -0,0 +1,267 @@
#pragma once
#ifndef MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_FILTER_H
#define MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_FILTER_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__Filter)
typedef Konsole::Filter Konsole__Filter;
#else
class Konsole__Filter;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__Filter__HotSpot)
typedef Konsole::Filter::HotSpot Konsole__Filter__HotSpot;
#else
class Konsole__Filter__HotSpot;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__FilterChain)
typedef Konsole::FilterChain Konsole__FilterChain;
#else
class Konsole__FilterChain;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__FilterObject)
typedef Konsole::FilterObject Konsole__FilterObject;
#else
class Konsole__FilterObject;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__RegExpFilter)
typedef Konsole::RegExpFilter Konsole__RegExpFilter;
#else
class Konsole__RegExpFilter;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__RegExpFilter__HotSpot)
typedef Konsole::RegExpFilter::HotSpot Konsole__RegExpFilter__HotSpot;
#else
class Konsole__RegExpFilter__HotSpot;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__TerminalImageFilterChain)
typedef Konsole::TerminalImageFilterChain Konsole__TerminalImageFilterChain;
#else
class Konsole__TerminalImageFilterChain;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__UrlFilter)
typedef Konsole::UrlFilter Konsole__UrlFilter;
#else
class Konsole__UrlFilter;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__UrlFilter__HotSpot)
typedef Konsole::UrlFilter::HotSpot Konsole__UrlFilter__HotSpot;
#else
class Konsole__UrlFilter__HotSpot;
#endif
class QAction;
class QChildEvent;
class QEvent;
class QMetaMethod;
class QMetaObject;
class QObject;
class QRegExp;
class QTimerEvent;
class QUrl;
#else
typedef struct Konsole__Filter Konsole__Filter;
typedef struct Konsole__Filter__HotSpot Konsole__Filter__HotSpot;
typedef struct Konsole__FilterChain Konsole__FilterChain;
typedef struct Konsole__FilterObject Konsole__FilterObject;
typedef struct Konsole__RegExpFilter Konsole__RegExpFilter;
typedef struct Konsole__RegExpFilter__HotSpot Konsole__RegExpFilter__HotSpot;
typedef struct Konsole__TerminalImageFilterChain Konsole__TerminalImageFilterChain;
typedef struct Konsole__UrlFilter Konsole__UrlFilter;
typedef struct Konsole__UrlFilter__HotSpot Konsole__UrlFilter__HotSpot;
typedef struct QAction QAction;
typedef struct QChildEvent QChildEvent;
typedef struct QEvent QEvent;
typedef struct QMetaMethod QMetaMethod;
typedef struct QMetaObject QMetaObject;
typedef struct QObject QObject;
typedef struct QRegExp QRegExp;
typedef struct QTimerEvent QTimerEvent;
typedef struct QUrl QUrl;
#endif
Konsole__Filter* Konsole__Filter_new();
void Konsole__Filter_virtbase(Konsole__Filter* src, QObject** outptr_QObject);
void Konsole__Filter_process(Konsole__Filter* self);
void Konsole__Filter_reset(Konsole__Filter* self);
Konsole__Filter__HotSpot* Konsole__Filter_hotSpotAt(const Konsole__Filter* self, int line, int column);
struct miqt_array /* of Konsole__Filter__HotSpot* */ Konsole__Filter_hotSpots(const Konsole__Filter* self);
struct miqt_array /* of Konsole__Filter__HotSpot* */ Konsole__Filter_hotSpotsAtLine(const Konsole__Filter* self, int line);
bool Konsole__Filter_override_virtual_process(void* self, intptr_t slot);
void Konsole__Filter_virtualbase_process(void* self);
bool Konsole__Filter_override_virtual_event(void* self, intptr_t slot);
bool Konsole__Filter_virtualbase_event(void* self, QEvent* event);
bool Konsole__Filter_override_virtual_eventFilter(void* self, intptr_t slot);
bool Konsole__Filter_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
bool Konsole__Filter_override_virtual_timerEvent(void* self, intptr_t slot);
void Konsole__Filter_virtualbase_timerEvent(void* self, QTimerEvent* event);
bool Konsole__Filter_override_virtual_childEvent(void* self, intptr_t slot);
void Konsole__Filter_virtualbase_childEvent(void* self, QChildEvent* event);
bool Konsole__Filter_override_virtual_customEvent(void* self, intptr_t slot);
void Konsole__Filter_virtualbase_customEvent(void* self, QEvent* event);
bool Konsole__Filter_override_virtual_connectNotify(void* self, intptr_t slot);
void Konsole__Filter_virtualbase_connectNotify(void* self, QMetaMethod* signal);
bool Konsole__Filter_override_virtual_disconnectNotify(void* self, intptr_t slot);
void Konsole__Filter_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
void Konsole__Filter_protectedbase_addHotSpot(bool* _dynamic_cast_ok, void* self, Konsole__Filter__HotSpot* param1);
struct miqt_string Konsole__Filter_protectedbase_buffer(bool* _dynamic_cast_ok, void* self);
void Konsole__Filter_protectedbase_getLineColumn(bool* _dynamic_cast_ok, void* self, int position, int* startLine, int* startColumn);
QObject* Konsole__Filter_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
int Konsole__Filter_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
int Konsole__Filter_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
bool Konsole__Filter_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
void Konsole__Filter_delete(Konsole__Filter* self);
Konsole__RegExpFilter* Konsole__RegExpFilter_new();
void Konsole__RegExpFilter_virtbase(Konsole__RegExpFilter* src, Konsole__Filter** outptr_Konsole__Filter);
void Konsole__RegExpFilter_setRegExp(Konsole__RegExpFilter* self, QRegExp* text);
QRegExp* Konsole__RegExpFilter_regExp(const Konsole__RegExpFilter* self);
void Konsole__RegExpFilter_process(Konsole__RegExpFilter* self);
bool Konsole__RegExpFilter_override_virtual_process(void* self, intptr_t slot);
void Konsole__RegExpFilter_virtualbase_process(void* self);
bool Konsole__RegExpFilter_override_virtual_event(void* self, intptr_t slot);
bool Konsole__RegExpFilter_virtualbase_event(void* self, QEvent* event);
bool Konsole__RegExpFilter_override_virtual_eventFilter(void* self, intptr_t slot);
bool Konsole__RegExpFilter_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
bool Konsole__RegExpFilter_override_virtual_timerEvent(void* self, intptr_t slot);
void Konsole__RegExpFilter_virtualbase_timerEvent(void* self, QTimerEvent* event);
bool Konsole__RegExpFilter_override_virtual_childEvent(void* self, intptr_t slot);
void Konsole__RegExpFilter_virtualbase_childEvent(void* self, QChildEvent* event);
bool Konsole__RegExpFilter_override_virtual_customEvent(void* self, intptr_t slot);
void Konsole__RegExpFilter_virtualbase_customEvent(void* self, QEvent* event);
bool Konsole__RegExpFilter_override_virtual_connectNotify(void* self, intptr_t slot);
void Konsole__RegExpFilter_virtualbase_connectNotify(void* self, QMetaMethod* signal);
bool Konsole__RegExpFilter_override_virtual_disconnectNotify(void* self, intptr_t slot);
void Konsole__RegExpFilter_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
void Konsole__RegExpFilter_protectedbase_addHotSpot(bool* _dynamic_cast_ok, void* self, Konsole__Filter__HotSpot* param1);
struct miqt_string Konsole__RegExpFilter_protectedbase_buffer(bool* _dynamic_cast_ok, void* self);
void Konsole__RegExpFilter_protectedbase_getLineColumn(bool* _dynamic_cast_ok, void* self, int position, int* startLine, int* startColumn);
QObject* Konsole__RegExpFilter_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
int Konsole__RegExpFilter_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
int Konsole__RegExpFilter_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
bool Konsole__RegExpFilter_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
void Konsole__RegExpFilter_delete(Konsole__RegExpFilter* self);
Konsole__UrlFilter* Konsole__UrlFilter_new();
void Konsole__UrlFilter_virtbase(Konsole__UrlFilter* src, Konsole__RegExpFilter** outptr_Konsole__RegExpFilter);
QMetaObject* Konsole__UrlFilter_metaObject(const Konsole__UrlFilter* self);
void* Konsole__UrlFilter_metacast(Konsole__UrlFilter* self, const char* param1);
struct miqt_string Konsole__UrlFilter_tr(const char* s);
struct miqt_string Konsole__UrlFilter_trUtf8(const char* s);
void Konsole__UrlFilter_activated(Konsole__UrlFilter* self, QUrl* url, bool fromContextMenu);
void Konsole__UrlFilter_connect_activated(Konsole__UrlFilter* self, intptr_t slot);
struct miqt_string Konsole__UrlFilter_tr2(const char* s, const char* c);
struct miqt_string Konsole__UrlFilter_tr3(const char* s, const char* c, int n);
struct miqt_string Konsole__UrlFilter_trUtf82(const char* s, const char* c);
struct miqt_string Konsole__UrlFilter_trUtf83(const char* s, const char* c, int n);
bool Konsole__UrlFilter_override_virtual_process(void* self, intptr_t slot);
void Konsole__UrlFilter_virtualbase_process(void* self);
bool Konsole__UrlFilter_override_virtual_event(void* self, intptr_t slot);
bool Konsole__UrlFilter_virtualbase_event(void* self, QEvent* event);
bool Konsole__UrlFilter_override_virtual_eventFilter(void* self, intptr_t slot);
bool Konsole__UrlFilter_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
bool Konsole__UrlFilter_override_virtual_timerEvent(void* self, intptr_t slot);
void Konsole__UrlFilter_virtualbase_timerEvent(void* self, QTimerEvent* event);
bool Konsole__UrlFilter_override_virtual_childEvent(void* self, intptr_t slot);
void Konsole__UrlFilter_virtualbase_childEvent(void* self, QChildEvent* event);
bool Konsole__UrlFilter_override_virtual_customEvent(void* self, intptr_t slot);
void Konsole__UrlFilter_virtualbase_customEvent(void* self, QEvent* event);
bool Konsole__UrlFilter_override_virtual_connectNotify(void* self, intptr_t slot);
void Konsole__UrlFilter_virtualbase_connectNotify(void* self, QMetaMethod* signal);
bool Konsole__UrlFilter_override_virtual_disconnectNotify(void* self, intptr_t slot);
void Konsole__UrlFilter_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
void Konsole__UrlFilter_protectedbase_addHotSpot(bool* _dynamic_cast_ok, void* self, Konsole__Filter__HotSpot* param1);
struct miqt_string Konsole__UrlFilter_protectedbase_buffer(bool* _dynamic_cast_ok, void* self);
void Konsole__UrlFilter_protectedbase_getLineColumn(bool* _dynamic_cast_ok, void* self, int position, int* startLine, int* startColumn);
QObject* Konsole__UrlFilter_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
int Konsole__UrlFilter_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
int Konsole__UrlFilter_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
bool Konsole__UrlFilter_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
void Konsole__UrlFilter_delete(Konsole__UrlFilter* self);
void Konsole__FilterObject_virtbase(Konsole__FilterObject* src, QObject** outptr_QObject);
QMetaObject* Konsole__FilterObject_metaObject(const Konsole__FilterObject* self);
void* Konsole__FilterObject_metacast(Konsole__FilterObject* self, const char* param1);
struct miqt_string Konsole__FilterObject_tr(const char* s);
struct miqt_string Konsole__FilterObject_trUtf8(const char* s);
void Konsole__FilterObject_emitActivated(Konsole__FilterObject* self, QUrl* url, bool fromContextMenu);
void Konsole__FilterObject_activate(Konsole__FilterObject* self);
void Konsole__FilterObject_activated(Konsole__FilterObject* self, QUrl* url, bool fromContextMenu);
void Konsole__FilterObject_connect_activated(Konsole__FilterObject* self, intptr_t slot);
struct miqt_string Konsole__FilterObject_tr2(const char* s, const char* c);
struct miqt_string Konsole__FilterObject_tr3(const char* s, const char* c, int n);
struct miqt_string Konsole__FilterObject_trUtf82(const char* s, const char* c);
struct miqt_string Konsole__FilterObject_trUtf83(const char* s, const char* c, int n);
void Konsole__FilterObject_delete(Konsole__FilterObject* self);
Konsole__FilterChain* Konsole__FilterChain_new(Konsole__FilterChain* param1);
void Konsole__FilterChain_addFilter(Konsole__FilterChain* self, Konsole__Filter* filter);
void Konsole__FilterChain_removeFilter(Konsole__FilterChain* self, Konsole__Filter* filter);
bool Konsole__FilterChain_containsFilter(Konsole__FilterChain* self, Konsole__Filter* filter);
void Konsole__FilterChain_clear(Konsole__FilterChain* self);
void Konsole__FilterChain_reset(Konsole__FilterChain* self);
void Konsole__FilterChain_process(Konsole__FilterChain* self);
void Konsole__FilterChain_operatorAssign(Konsole__FilterChain* self, Konsole__FilterChain* param1);
void Konsole__FilterChain_delete(Konsole__FilterChain* self);
Konsole__TerminalImageFilterChain* Konsole__TerminalImageFilterChain_new();
Konsole__TerminalImageFilterChain* Konsole__TerminalImageFilterChain_new2(Konsole__TerminalImageFilterChain* param1);
void Konsole__TerminalImageFilterChain_virtbase(Konsole__TerminalImageFilterChain* src, Konsole__FilterChain** outptr_Konsole__FilterChain);
void Konsole__TerminalImageFilterChain_delete(Konsole__TerminalImageFilterChain* self);
Konsole__Filter__HotSpot* Konsole__Filter__HotSpot_new(int startLine, int startColumn, int endLine, int endColumn);
Konsole__Filter__HotSpot* Konsole__Filter__HotSpot_new2(Konsole__Filter__HotSpot* param1);
int Konsole__Filter__HotSpot_startLine(const Konsole__Filter__HotSpot* self);
int Konsole__Filter__HotSpot_endLine(const Konsole__Filter__HotSpot* self);
int Konsole__Filter__HotSpot_startColumn(const Konsole__Filter__HotSpot* self);
int Konsole__Filter__HotSpot_endColumn(const Konsole__Filter__HotSpot* self);
int Konsole__Filter__HotSpot_type(const Konsole__Filter__HotSpot* self);
void Konsole__Filter__HotSpot_activate(Konsole__Filter__HotSpot* self, struct miqt_string action);
struct miqt_array /* of QAction* */ Konsole__Filter__HotSpot_actions(Konsole__Filter__HotSpot* self);
bool Konsole__Filter__HotSpot_override_virtual_activate(void* self, intptr_t slot);
void Konsole__Filter__HotSpot_virtualbase_activate(void* self, struct miqt_string action);
bool Konsole__Filter__HotSpot_override_virtual_actions(void* self, intptr_t slot);
struct miqt_array /* of QAction* */ Konsole__Filter__HotSpot_virtualbase_actions(void* self);
void Konsole__Filter__HotSpot_protectedbase_setType(bool* _dynamic_cast_ok, void* self, int type);
void Konsole__Filter__HotSpot_delete(Konsole__Filter__HotSpot* self);
Konsole__RegExpFilter__HotSpot* Konsole__RegExpFilter__HotSpot_new(int startLine, int startColumn, int endLine, int endColumn);
Konsole__RegExpFilter__HotSpot* Konsole__RegExpFilter__HotSpot_new2(Konsole__RegExpFilter__HotSpot* param1);
void Konsole__RegExpFilter__HotSpot_virtbase(Konsole__RegExpFilter__HotSpot* src, Konsole__Filter__HotSpot** outptr_Konsole__Filter__HotSpot);
void Konsole__RegExpFilter__HotSpot_activate(Konsole__RegExpFilter__HotSpot* self, struct miqt_string action);
void Konsole__RegExpFilter__HotSpot_setCapturedTexts(Konsole__RegExpFilter__HotSpot* self, struct miqt_array /* of struct miqt_string */ texts);
struct miqt_array /* of struct miqt_string */ Konsole__RegExpFilter__HotSpot_capturedTexts(const Konsole__RegExpFilter__HotSpot* self);
bool Konsole__RegExpFilter__HotSpot_override_virtual_activate(void* self, intptr_t slot);
void Konsole__RegExpFilter__HotSpot_virtualbase_activate(void* self, struct miqt_string action);
bool Konsole__RegExpFilter__HotSpot_override_virtual_actions(void* self, intptr_t slot);
struct miqt_array /* of QAction* */ Konsole__RegExpFilter__HotSpot_virtualbase_actions(void* self);
void Konsole__RegExpFilter__HotSpot_protectedbase_setType(bool* _dynamic_cast_ok, void* self, int type);
void Konsole__RegExpFilter__HotSpot_delete(Konsole__RegExpFilter__HotSpot* self);
Konsole__UrlFilter__HotSpot* Konsole__UrlFilter__HotSpot_new(int startLine, int startColumn, int endLine, int endColumn);
void Konsole__UrlFilter__HotSpot_virtbase(Konsole__UrlFilter__HotSpot* src, Konsole__RegExpFilter__HotSpot** outptr_Konsole__RegExpFilter__HotSpot);
Konsole__FilterObject* Konsole__UrlFilter__HotSpot_getUrlObject(const Konsole__UrlFilter__HotSpot* self);
struct miqt_array /* of QAction* */ Konsole__UrlFilter__HotSpot_actions(Konsole__UrlFilter__HotSpot* self);
void Konsole__UrlFilter__HotSpot_activate(Konsole__UrlFilter__HotSpot* self, struct miqt_string action);
bool Konsole__UrlFilter__HotSpot_override_virtual_actions(void* self, intptr_t slot);
struct miqt_array /* of QAction* */ Konsole__UrlFilter__HotSpot_virtualbase_actions(void* self);
bool Konsole__UrlFilter__HotSpot_override_virtual_activate(void* self, intptr_t slot);
void Konsole__UrlFilter__HotSpot_virtualbase_activate(void* self, struct miqt_string action);
void Konsole__UrlFilter__HotSpot_protectedbase_setType(bool* _dynamic_cast_ok, void* self, int type);
void Konsole__UrlFilter__HotSpot_delete(Konsole__UrlFilter__HotSpot* self);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

374
qt-restricted-extras/qtermwidget/gen_KeyboardTranslator.cpp Normal file
View File

@ -0,0 +1,374 @@
#define WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslator
#define WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslator__Entry
#define WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslatorManager
#define WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslatorReader
#define WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslatorWriter
#include <QByteArray>
#include <QIODevice>
#include <QList>
#include <QString>
#include <QByteArray>
#include <cstring>
#include <KeyboardTranslator.h>
#include "gen_KeyboardTranslator.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
} /* extern C */
#endif
Konsole__KeyboardTranslator* Konsole__KeyboardTranslator_new(struct miqt_string name) {
QString name_QString = QString::fromUtf8(name.data, name.len);
return new Konsole::KeyboardTranslator(name_QString);
}
Konsole__KeyboardTranslator* Konsole__KeyboardTranslator_new2(Konsole__KeyboardTranslator* param1) {
return new Konsole::KeyboardTranslator(*param1);
}
struct miqt_string Konsole__KeyboardTranslator_name(const Konsole__KeyboardTranslator* self) {
QString _ret = self->name();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
void Konsole__KeyboardTranslator_setName(Konsole__KeyboardTranslator* self, struct miqt_string name) {
QString name_QString = QString::fromUtf8(name.data, name.len);
self->setName(name_QString);
}
struct miqt_string Konsole__KeyboardTranslator_description(const Konsole__KeyboardTranslator* self) {
QString _ret = self->description();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
void Konsole__KeyboardTranslator_setDescription(Konsole__KeyboardTranslator* self, struct miqt_string description) {
QString description_QString = QString::fromUtf8(description.data, description.len);
self->setDescription(description_QString);
}
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator_findEntry(const Konsole__KeyboardTranslator* self, int keyCode, int modifiers) {
return new Konsole::KeyboardTranslator::Entry(self->findEntry(static_cast<int>(keyCode), static_cast<Qt::KeyboardModifiers>(modifiers)));
}
void Konsole__KeyboardTranslator_addEntry(Konsole__KeyboardTranslator* self, Konsole__KeyboardTranslator__Entry* entry) {
self->addEntry(*entry);
}
void Konsole__KeyboardTranslator_replaceEntry(Konsole__KeyboardTranslator* self, Konsole__KeyboardTranslator__Entry* existing, Konsole__KeyboardTranslator__Entry* replacement) {
self->replaceEntry(*existing, *replacement);
}
void Konsole__KeyboardTranslator_removeEntry(Konsole__KeyboardTranslator* self, Konsole__KeyboardTranslator__Entry* entry) {
self->removeEntry(*entry);
}
struct miqt_array /* of Konsole__KeyboardTranslator__Entry* */ Konsole__KeyboardTranslator_entries(const Konsole__KeyboardTranslator* self) {
QList<Konsole::KeyboardTranslator::Entry> _ret = self->entries();
// Convert QList<> from C++ memory to manually-managed C memory
Konsole__KeyboardTranslator__Entry** _arr = static_cast<Konsole__KeyboardTranslator__Entry**>(malloc(sizeof(Konsole__KeyboardTranslator__Entry*) * _ret.length()));
for (size_t i = 0, e = _ret.length(); i < e; ++i) {
_arr[i] = new Konsole::KeyboardTranslator::Entry(_ret[i]);
}
struct miqt_array _out;
_out.len = _ret.length();
_out.data = static_cast<void*>(_arr);
return _out;
}
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator_findEntry2(const Konsole__KeyboardTranslator* self, int keyCode, int modifiers, int state) {
return new Konsole::KeyboardTranslator::Entry(self->findEntry(static_cast<int>(keyCode), static_cast<Qt::KeyboardModifiers>(modifiers), static_cast<Konsole::KeyboardTranslator::States>(state)));
}
void Konsole__KeyboardTranslator_delete(Konsole__KeyboardTranslator* self) {
delete self;
}
Konsole__KeyboardTranslatorReader* Konsole__KeyboardTranslatorReader_new(QIODevice* source) {
return new Konsole::KeyboardTranslatorReader(source);
}
Konsole__KeyboardTranslatorReader* Konsole__KeyboardTranslatorReader_new2(Konsole__KeyboardTranslatorReader* param1) {
return new Konsole::KeyboardTranslatorReader(*param1);
}
struct miqt_string Konsole__KeyboardTranslatorReader_description(const Konsole__KeyboardTranslatorReader* self) {
QString _ret = self->description();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
bool Konsole__KeyboardTranslatorReader_hasNextEntry(const Konsole__KeyboardTranslatorReader* self) {
return self->hasNextEntry();
}
bool Konsole__KeyboardTranslatorReader_parseError(Konsole__KeyboardTranslatorReader* self) {
return self->parseError();
}
void Konsole__KeyboardTranslatorReader_delete(Konsole__KeyboardTranslatorReader* self) {
delete self;
}
Konsole__KeyboardTranslatorWriter* Konsole__KeyboardTranslatorWriter_new(QIODevice* destination) {
return new Konsole::KeyboardTranslatorWriter(destination);
}
void Konsole__KeyboardTranslatorWriter_writeHeader(Konsole__KeyboardTranslatorWriter* self, struct miqt_string description) {
QString description_QString = QString::fromUtf8(description.data, description.len);
self->writeHeader(description_QString);
}
void Konsole__KeyboardTranslatorWriter_delete(Konsole__KeyboardTranslatorWriter* self) {
delete self;
}
Konsole__KeyboardTranslatorManager* Konsole__KeyboardTranslatorManager_new() {
return new Konsole::KeyboardTranslatorManager();
}
void Konsole__KeyboardTranslatorManager_addTranslator(Konsole__KeyboardTranslatorManager* self, Konsole__KeyboardTranslator* translator) {
self->addTranslator(translator);
}
bool Konsole__KeyboardTranslatorManager_deleteTranslator(Konsole__KeyboardTranslatorManager* self, struct miqt_string name) {
QString name_QString = QString::fromUtf8(name.data, name.len);
return self->deleteTranslator(name_QString);
}
Konsole__KeyboardTranslator* Konsole__KeyboardTranslatorManager_defaultTranslator(Konsole__KeyboardTranslatorManager* self) {
return (Konsole__KeyboardTranslator*) self->defaultTranslator();
}
Konsole__KeyboardTranslator* Konsole__KeyboardTranslatorManager_findTranslator(Konsole__KeyboardTranslatorManager* self, struct miqt_string name) {
QString name_QString = QString::fromUtf8(name.data, name.len);
return (Konsole__KeyboardTranslator*) self->findTranslator(name_QString);
}
struct miqt_array /* of struct miqt_string */ Konsole__KeyboardTranslatorManager_allTranslators(Konsole__KeyboardTranslatorManager* self) {
QList<QString> _ret = self->allTranslators();
// Convert QList<> from C++ memory to manually-managed C memory
struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
for (size_t i = 0, e = _ret.length(); i < e; ++i) {
QString _lv_ret = _ret[i];
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _lv_b = _lv_ret.toUtf8();
struct miqt_string _lv_ms;
_lv_ms.len = _lv_b.length();
_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
_arr[i] = _lv_ms;
}
struct miqt_array _out;
_out.len = _ret.length();
_out.data = static_cast<void*>(_arr);
return _out;
}
Konsole__KeyboardTranslatorManager* Konsole__KeyboardTranslatorManager_instance() {
return Konsole::KeyboardTranslatorManager::instance();
}
void Konsole__KeyboardTranslatorManager_delete(Konsole__KeyboardTranslatorManager* self) {
delete self;
}
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator__Entry_new() {
return new Konsole::KeyboardTranslator::Entry();
}
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator__Entry_new2(Konsole__KeyboardTranslator__Entry* param1) {
return new Konsole::KeyboardTranslator::Entry(*param1);
}
bool Konsole__KeyboardTranslator__Entry_isNull(const Konsole__KeyboardTranslator__Entry* self) {
return self->isNull();
}
int Konsole__KeyboardTranslator__Entry_command(const Konsole__KeyboardTranslator__Entry* self) {
Konsole::KeyboardTranslator::Command _ret = self->command();
return static_cast<int>(_ret);
}
void Konsole__KeyboardTranslator__Entry_setCommand(Konsole__KeyboardTranslator__Entry* self, int command) {
self->setCommand(static_cast<Konsole::KeyboardTranslator::Command>(command));
}
struct miqt_string Konsole__KeyboardTranslator__Entry_text(const Konsole__KeyboardTranslator__Entry* self) {
QByteArray _qb = self->text();
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
void Konsole__KeyboardTranslator__Entry_setText(Konsole__KeyboardTranslator__Entry* self, struct miqt_string text) {
QByteArray text_QByteArray(text.data, text.len);
self->setText(text_QByteArray);
}
struct miqt_string Konsole__KeyboardTranslator__Entry_escapedText(const Konsole__KeyboardTranslator__Entry* self) {
QByteArray _qb = self->escapedText();
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
int Konsole__KeyboardTranslator__Entry_keyCode(const Konsole__KeyboardTranslator__Entry* self) {
return self->keyCode();
}
void Konsole__KeyboardTranslator__Entry_setKeyCode(Konsole__KeyboardTranslator__Entry* self, int keyCode) {
self->setKeyCode(static_cast<int>(keyCode));
}
int Konsole__KeyboardTranslator__Entry_modifiers(const Konsole__KeyboardTranslator__Entry* self) {
Qt::KeyboardModifiers _ret = self->modifiers();
return static_cast<int>(_ret);
}
int Konsole__KeyboardTranslator__Entry_modifierMask(const Konsole__KeyboardTranslator__Entry* self) {
Qt::KeyboardModifiers _ret = self->modifierMask();
return static_cast<int>(_ret);
}
void Konsole__KeyboardTranslator__Entry_setModifiers(Konsole__KeyboardTranslator__Entry* self, int modifiers) {
self->setModifiers(static_cast<Qt::KeyboardModifiers>(modifiers));
}
void Konsole__KeyboardTranslator__Entry_setModifierMask(Konsole__KeyboardTranslator__Entry* self, int modifiers) {
self->setModifierMask(static_cast<Qt::KeyboardModifiers>(modifiers));
}
int Konsole__KeyboardTranslator__Entry_state(const Konsole__KeyboardTranslator__Entry* self) {
Konsole::KeyboardTranslator::States _ret = self->state();
return static_cast<int>(_ret);
}
int Konsole__KeyboardTranslator__Entry_stateMask(const Konsole__KeyboardTranslator__Entry* self) {
Konsole::KeyboardTranslator::States _ret = self->stateMask();
return static_cast<int>(_ret);
}
void Konsole__KeyboardTranslator__Entry_setState(Konsole__KeyboardTranslator__Entry* self, int state) {
self->setState(static_cast<Konsole::KeyboardTranslator::States>(state));
}
void Konsole__KeyboardTranslator__Entry_setStateMask(Konsole__KeyboardTranslator__Entry* self, int mask) {
self->setStateMask(static_cast<Konsole::KeyboardTranslator::States>(mask));
}
struct miqt_string Konsole__KeyboardTranslator__Entry_conditionToString(const Konsole__KeyboardTranslator__Entry* self) {
QString _ret = self->conditionToString();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
struct miqt_string Konsole__KeyboardTranslator__Entry_resultToString(const Konsole__KeyboardTranslator__Entry* self) {
QString _ret = self->resultToString();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
bool Konsole__KeyboardTranslator__Entry_matches(const Konsole__KeyboardTranslator__Entry* self, int keyCode, int modifiers, int flags) {
return self->matches(static_cast<int>(keyCode), static_cast<Qt::KeyboardModifiers>(modifiers), static_cast<Konsole::KeyboardTranslator::States>(flags));
}
bool Konsole__KeyboardTranslator__Entry_operatorEqual(const Konsole__KeyboardTranslator__Entry* self, Konsole__KeyboardTranslator__Entry* rhs) {
return (*self == *rhs);
}
struct miqt_string Konsole__KeyboardTranslator__Entry_textWithExpandWildCards(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards) {
QByteArray _qb = self->text(expandWildCards);
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
struct miqt_string Konsole__KeyboardTranslator__Entry_text2(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards, int modifiers) {
QByteArray _qb = self->text(expandWildCards, static_cast<Qt::KeyboardModifiers>(modifiers));
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
struct miqt_string Konsole__KeyboardTranslator__Entry_escapedTextWithExpandWildCards(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards) {
QByteArray _qb = self->escapedText(expandWildCards);
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
struct miqt_string Konsole__KeyboardTranslator__Entry_escapedText2(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards, int modifiers) {
QByteArray _qb = self->escapedText(expandWildCards, static_cast<Qt::KeyboardModifiers>(modifiers));
struct miqt_string _ms;
_ms.len = _qb.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _qb.data(), _ms.len);
return _ms;
}
struct miqt_string Konsole__KeyboardTranslator__Entry_resultToStringWithExpandWildCards(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards) {
QString _ret = self->resultToString(expandWildCards);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
struct miqt_string Konsole__KeyboardTranslator__Entry_resultToString2(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards, int modifiers) {
QString _ret = self->resultToString(expandWildCards, static_cast<Qt::KeyboardModifiers>(modifiers));
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
void Konsole__KeyboardTranslator__Entry_delete(Konsole__KeyboardTranslator__Entry* self) {
delete self;
}

595
qt-restricted-extras/qtermwidget/gen_KeyboardTranslator.go Normal file
View File

@ -0,0 +1,595 @@
package qtermwidget
/*
#include "gen_KeyboardTranslator.h"
#include <stdlib.h>
*/
import "C"
import (
"github.com/mappu/miqt/qt"
"runtime"
"unsafe"
)
type Konsole__KeyboardTranslator__State int
const (
Konsole__KeyboardTranslator__NoState Konsole__KeyboardTranslator__State = 0
Konsole__KeyboardTranslator__NewLineState Konsole__KeyboardTranslator__State = 1
Konsole__KeyboardTranslator__AnsiState Konsole__KeyboardTranslator__State = 2
Konsole__KeyboardTranslator__CursorKeysState Konsole__KeyboardTranslator__State = 4
Konsole__KeyboardTranslator__AlternateScreenState Konsole__KeyboardTranslator__State = 8
Konsole__KeyboardTranslator__AnyModifierState Konsole__KeyboardTranslator__State = 16
Konsole__KeyboardTranslator__ApplicationKeypadState Konsole__KeyboardTranslator__State = 32
)
type Konsole__KeyboardTranslator__Command int
const (
Konsole__KeyboardTranslator__NoCommand Konsole__KeyboardTranslator__Command = 0
Konsole__KeyboardTranslator__SendCommand Konsole__KeyboardTranslator__Command = 1
Konsole__KeyboardTranslator__ScrollPageUpCommand Konsole__KeyboardTranslator__Command = 2
Konsole__KeyboardTranslator__ScrollPageDownCommand Konsole__KeyboardTranslator__Command = 4
Konsole__KeyboardTranslator__ScrollLineUpCommand Konsole__KeyboardTranslator__Command = 8
Konsole__KeyboardTranslator__ScrollLineDownCommand Konsole__KeyboardTranslator__Command = 16
Konsole__KeyboardTranslator__ScrollLockCommand Konsole__KeyboardTranslator__Command = 32
Konsole__KeyboardTranslator__ScrollUpToTopCommand Konsole__KeyboardTranslator__Command = 64
Konsole__KeyboardTranslator__ScrollDownToBottomCommand Konsole__KeyboardTranslator__Command = 128
Konsole__KeyboardTranslator__EraseCommand Konsole__KeyboardTranslator__Command = 256
)
type Konsole__KeyboardTranslator struct {
h *C.Konsole__KeyboardTranslator
}
func (this *Konsole__KeyboardTranslator) cPointer() *C.Konsole__KeyboardTranslator {
if this == nil {
return nil
}
return this.h
}
func (this *Konsole__KeyboardTranslator) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newKonsole__KeyboardTranslator constructs the type using only CGO pointers.
func newKonsole__KeyboardTranslator(h *C.Konsole__KeyboardTranslator) *Konsole__KeyboardTranslator {
if h == nil {
return nil
}
return &Konsole__KeyboardTranslator{h: h}
}
// UnsafeNewKonsole__KeyboardTranslator constructs the type using only unsafe pointers.
func UnsafeNewKonsole__KeyboardTranslator(h unsafe.Pointer) *Konsole__KeyboardTranslator {
return newKonsole__KeyboardTranslator((*C.Konsole__KeyboardTranslator)(h))
}
// NewKonsole__KeyboardTranslator constructs a new Konsole::KeyboardTranslator object.
func NewKonsole__KeyboardTranslator(name string) *Konsole__KeyboardTranslator {
name_ms := C.struct_miqt_string{}
name_ms.data = C.CString(name)
name_ms.len = C.size_t(len(name))
defer C.free(unsafe.Pointer(name_ms.data))
return newKonsole__KeyboardTranslator(C.Konsole__KeyboardTranslator_new(name_ms))
}
// NewKonsole__KeyboardTranslator2 constructs a new Konsole::KeyboardTranslator object.
func NewKonsole__KeyboardTranslator2(param1 *Konsole__KeyboardTranslator) *Konsole__KeyboardTranslator {
return newKonsole__KeyboardTranslator(C.Konsole__KeyboardTranslator_new2(param1.cPointer()))
}
func (this *Konsole__KeyboardTranslator) Name() string {
var _ms C.struct_miqt_string = C.Konsole__KeyboardTranslator_name(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *Konsole__KeyboardTranslator) SetName(name string) {
name_ms := C.struct_miqt_string{}
name_ms.data = C.CString(name)
name_ms.len = C.size_t(len(name))
defer C.free(unsafe.Pointer(name_ms.data))
C.Konsole__KeyboardTranslator_setName(this.h, name_ms)
}
func (this *Konsole__KeyboardTranslator) Description() string {
var _ms C.struct_miqt_string = C.Konsole__KeyboardTranslator_description(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *Konsole__KeyboardTranslator) SetDescription(description string) {
description_ms := C.struct_miqt_string{}
description_ms.data = C.CString(description)
description_ms.len = C.size_t(len(description))
defer C.free(unsafe.Pointer(description_ms.data))
C.Konsole__KeyboardTranslator_setDescription(this.h, description_ms)
}
func (this *Konsole__KeyboardTranslator) FindEntry(keyCode int, modifiers qt.KeyboardModifier) *Konsole__KeyboardTranslator__Entry {
_goptr := newKonsole__KeyboardTranslator__Entry(C.Konsole__KeyboardTranslator_findEntry(this.h, (C.int)(keyCode), (C.int)(modifiers)))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *Konsole__KeyboardTranslator) AddEntry(entry *Konsole__KeyboardTranslator__Entry) {
C.Konsole__KeyboardTranslator_addEntry(this.h, entry.cPointer())
}
func (this *Konsole__KeyboardTranslator) ReplaceEntry(existing *Konsole__KeyboardTranslator__Entry, replacement *Konsole__KeyboardTranslator__Entry) {
C.Konsole__KeyboardTranslator_replaceEntry(this.h, existing.cPointer(), replacement.cPointer())
}
func (this *Konsole__KeyboardTranslator) RemoveEntry(entry *Konsole__KeyboardTranslator__Entry) {
C.Konsole__KeyboardTranslator_removeEntry(this.h, entry.cPointer())
}
func (this *Konsole__KeyboardTranslator) Entries() []Konsole__KeyboardTranslator__Entry {
var _ma C.struct_miqt_array = C.Konsole__KeyboardTranslator_entries(this.h)
_ret := make([]Konsole__KeyboardTranslator__Entry, int(_ma.len))
_outCast := (*[0xffff]*C.Konsole__KeyboardTranslator__Entry)(unsafe.Pointer(_ma.data)) // hey ya
for i := 0; i < int(_ma.len); i++ {
_lv_goptr := newKonsole__KeyboardTranslator__Entry(_outCast[i])
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
_ret[i] = *_lv_goptr
}
return _ret
}
func (this *Konsole__KeyboardTranslator) FindEntry2(keyCode int, modifiers qt.KeyboardModifier, state Konsole__KeyboardTranslator__State) *Konsole__KeyboardTranslator__Entry {
_goptr := newKonsole__KeyboardTranslator__Entry(C.Konsole__KeyboardTranslator_findEntry2(this.h, (C.int)(keyCode), (C.int)(modifiers), (C.int)(state)))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
// Delete this object from C++ memory.
func (this *Konsole__KeyboardTranslator) Delete() {
C.Konsole__KeyboardTranslator_delete(this.h)
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *Konsole__KeyboardTranslator) GoGC() {
runtime.SetFinalizer(this, func(this *Konsole__KeyboardTranslator) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type Konsole__KeyboardTranslatorReader struct {
h *C.Konsole__KeyboardTranslatorReader
}
func (this *Konsole__KeyboardTranslatorReader) cPointer() *C.Konsole__KeyboardTranslatorReader {
if this == nil {
return nil
}
return this.h
}
func (this *Konsole__KeyboardTranslatorReader) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newKonsole__KeyboardTranslatorReader constructs the type using only CGO pointers.
func newKonsole__KeyboardTranslatorReader(h *C.Konsole__KeyboardTranslatorReader) *Konsole__KeyboardTranslatorReader {
if h == nil {
return nil
}
return &Konsole__KeyboardTranslatorReader{h: h}
}
// UnsafeNewKonsole__KeyboardTranslatorReader constructs the type using only unsafe pointers.
func UnsafeNewKonsole__KeyboardTranslatorReader(h unsafe.Pointer) *Konsole__KeyboardTranslatorReader {
return newKonsole__KeyboardTranslatorReader((*C.Konsole__KeyboardTranslatorReader)(h))
}
// NewKonsole__KeyboardTranslatorReader constructs a new Konsole::KeyboardTranslatorReader object.
func NewKonsole__KeyboardTranslatorReader(source *qt.QIODevice) *Konsole__KeyboardTranslatorReader {
return newKonsole__KeyboardTranslatorReader(C.Konsole__KeyboardTranslatorReader_new((*C.QIODevice)(source.UnsafePointer())))
}
// NewKonsole__KeyboardTranslatorReader2 constructs a new Konsole::KeyboardTranslatorReader object.
func NewKonsole__KeyboardTranslatorReader2(param1 *Konsole__KeyboardTranslatorReader) *Konsole__KeyboardTranslatorReader {
return newKonsole__KeyboardTranslatorReader(C.Konsole__KeyboardTranslatorReader_new2(param1.cPointer()))
}
func (this *Konsole__KeyboardTranslatorReader) Description() string {
var _ms C.struct_miqt_string = C.Konsole__KeyboardTranslatorReader_description(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *Konsole__KeyboardTranslatorReader) HasNextEntry() bool {
return (bool)(C.Konsole__KeyboardTranslatorReader_hasNextEntry(this.h))
}
func (this *Konsole__KeyboardTranslatorReader) ParseError() bool {
return (bool)(C.Konsole__KeyboardTranslatorReader_parseError(this.h))
}
// Delete this object from C++ memory.
func (this *Konsole__KeyboardTranslatorReader) Delete() {
C.Konsole__KeyboardTranslatorReader_delete(this.h)
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *Konsole__KeyboardTranslatorReader) GoGC() {
runtime.SetFinalizer(this, func(this *Konsole__KeyboardTranslatorReader) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type Konsole__KeyboardTranslatorWriter struct {
h *C.Konsole__KeyboardTranslatorWriter
}
func (this *Konsole__KeyboardTranslatorWriter) cPointer() *C.Konsole__KeyboardTranslatorWriter {
if this == nil {
return nil
}
return this.h
}
func (this *Konsole__KeyboardTranslatorWriter) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newKonsole__KeyboardTranslatorWriter constructs the type using only CGO pointers.
func newKonsole__KeyboardTranslatorWriter(h *C.Konsole__KeyboardTranslatorWriter) *Konsole__KeyboardTranslatorWriter {
if h == nil {
return nil
}
return &Konsole__KeyboardTranslatorWriter{h: h}
}
// UnsafeNewKonsole__KeyboardTranslatorWriter constructs the type using only unsafe pointers.
func UnsafeNewKonsole__KeyboardTranslatorWriter(h unsafe.Pointer) *Konsole__KeyboardTranslatorWriter {
return newKonsole__KeyboardTranslatorWriter((*C.Konsole__KeyboardTranslatorWriter)(h))
}
// NewKonsole__KeyboardTranslatorWriter constructs a new Konsole::KeyboardTranslatorWriter object.
func NewKonsole__KeyboardTranslatorWriter(destination *qt.QIODevice) *Konsole__KeyboardTranslatorWriter {
return newKonsole__KeyboardTranslatorWriter(C.Konsole__KeyboardTranslatorWriter_new((*C.QIODevice)(destination.UnsafePointer())))
}
func (this *Konsole__KeyboardTranslatorWriter) WriteHeader(description string) {
description_ms := C.struct_miqt_string{}
description_ms.data = C.CString(description)
description_ms.len = C.size_t(len(description))
defer C.free(unsafe.Pointer(description_ms.data))
C.Konsole__KeyboardTranslatorWriter_writeHeader(this.h, description_ms)
}
// Delete this object from C++ memory.
func (this *Konsole__KeyboardTranslatorWriter) Delete() {
C.Konsole__KeyboardTranslatorWriter_delete(this.h)
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *Konsole__KeyboardTranslatorWriter) GoGC() {
runtime.SetFinalizer(this, func(this *Konsole__KeyboardTranslatorWriter) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type Konsole__KeyboardTranslatorManager struct {
h *C.Konsole__KeyboardTranslatorManager
}
func (this *Konsole__KeyboardTranslatorManager) cPointer() *C.Konsole__KeyboardTranslatorManager {
if this == nil {
return nil
}
return this.h
}
func (this *Konsole__KeyboardTranslatorManager) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newKonsole__KeyboardTranslatorManager constructs the type using only CGO pointers.
func newKonsole__KeyboardTranslatorManager(h *C.Konsole__KeyboardTranslatorManager) *Konsole__KeyboardTranslatorManager {
if h == nil {
return nil
}
return &Konsole__KeyboardTranslatorManager{h: h}
}
// UnsafeNewKonsole__KeyboardTranslatorManager constructs the type using only unsafe pointers.
func UnsafeNewKonsole__KeyboardTranslatorManager(h unsafe.Pointer) *Konsole__KeyboardTranslatorManager {
return newKonsole__KeyboardTranslatorManager((*C.Konsole__KeyboardTranslatorManager)(h))
}
// NewKonsole__KeyboardTranslatorManager constructs a new Konsole::KeyboardTranslatorManager object.
func NewKonsole__KeyboardTranslatorManager() *Konsole__KeyboardTranslatorManager {
return newKonsole__KeyboardTranslatorManager(C.Konsole__KeyboardTranslatorManager_new())
}
func (this *Konsole__KeyboardTranslatorManager) AddTranslator(translator *Konsole__KeyboardTranslator) {
C.Konsole__KeyboardTranslatorManager_addTranslator(this.h, translator.cPointer())
}
func (this *Konsole__KeyboardTranslatorManager) DeleteTranslator(name string) bool {
name_ms := C.struct_miqt_string{}
name_ms.data = C.CString(name)
name_ms.len = C.size_t(len(name))
defer C.free(unsafe.Pointer(name_ms.data))
return (bool)(C.Konsole__KeyboardTranslatorManager_deleteTranslator(this.h, name_ms))
}
func (this *Konsole__KeyboardTranslatorManager) DefaultTranslator() *Konsole__KeyboardTranslator {
return newKonsole__KeyboardTranslator(C.Konsole__KeyboardTranslatorManager_defaultTranslator(this.h))
}
func (this *Konsole__KeyboardTranslatorManager) FindTranslator(name string) *Konsole__KeyboardTranslator {
name_ms := C.struct_miqt_string{}
name_ms.data = C.CString(name)
name_ms.len = C.size_t(len(name))
defer C.free(unsafe.Pointer(name_ms.data))
return newKonsole__KeyboardTranslator(C.Konsole__KeyboardTranslatorManager_findTranslator(this.h, name_ms))
}
func (this *Konsole__KeyboardTranslatorManager) AllTranslators() []string {
var _ma C.struct_miqt_array = C.Konsole__KeyboardTranslatorManager_allTranslators(this.h)
_ret := make([]string, int(_ma.len))
_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
for i := 0; i < int(_ma.len); i++ {
var _lv_ms C.struct_miqt_string = _outCast[i]
_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
C.free(unsafe.Pointer(_lv_ms.data))
_ret[i] = _lv_ret
}
return _ret
}
func Konsole__KeyboardTranslatorManager_Instance() *Konsole__KeyboardTranslatorManager {
return newKonsole__KeyboardTranslatorManager(C.Konsole__KeyboardTranslatorManager_instance())
}
// Delete this object from C++ memory.
func (this *Konsole__KeyboardTranslatorManager) Delete() {
C.Konsole__KeyboardTranslatorManager_delete(this.h)
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *Konsole__KeyboardTranslatorManager) GoGC() {
runtime.SetFinalizer(this, func(this *Konsole__KeyboardTranslatorManager) {
this.Delete()
runtime.KeepAlive(this.h)
})
}
type Konsole__KeyboardTranslator__Entry struct {
h *C.Konsole__KeyboardTranslator__Entry
}
func (this *Konsole__KeyboardTranslator__Entry) cPointer() *C.Konsole__KeyboardTranslator__Entry {
if this == nil {
return nil
}
return this.h
}
func (this *Konsole__KeyboardTranslator__Entry) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newKonsole__KeyboardTranslator__Entry constructs the type using only CGO pointers.
func newKonsole__KeyboardTranslator__Entry(h *C.Konsole__KeyboardTranslator__Entry) *Konsole__KeyboardTranslator__Entry {
if h == nil {
return nil
}
return &Konsole__KeyboardTranslator__Entry{h: h}
}
// UnsafeNewKonsole__KeyboardTranslator__Entry constructs the type using only unsafe pointers.
func UnsafeNewKonsole__KeyboardTranslator__Entry(h unsafe.Pointer) *Konsole__KeyboardTranslator__Entry {
return newKonsole__KeyboardTranslator__Entry((*C.Konsole__KeyboardTranslator__Entry)(h))
}
// NewKonsole__KeyboardTranslator__Entry constructs a new Konsole::KeyboardTranslator::Entry object.
func NewKonsole__KeyboardTranslator__Entry() *Konsole__KeyboardTranslator__Entry {
return newKonsole__KeyboardTranslator__Entry(C.Konsole__KeyboardTranslator__Entry_new())
}
// NewKonsole__KeyboardTranslator__Entry2 constructs a new Konsole::KeyboardTranslator::Entry object.
func NewKonsole__KeyboardTranslator__Entry2(param1 *Konsole__KeyboardTranslator__Entry) *Konsole__KeyboardTranslator__Entry {
return newKonsole__KeyboardTranslator__Entry(C.Konsole__KeyboardTranslator__Entry_new2(param1.cPointer()))
}
func (this *Konsole__KeyboardTranslator__Entry) IsNull() bool {
return (bool)(C.Konsole__KeyboardTranslator__Entry_isNull(this.h))
}
func (this *Konsole__KeyboardTranslator__Entry) Command() Konsole__KeyboardTranslator__Command {
return (Konsole__KeyboardTranslator__Command)(C.Konsole__KeyboardTranslator__Entry_command(this.h))
}
func (this *Konsole__KeyboardTranslator__Entry) SetCommand(command Konsole__KeyboardTranslator__Command) {
C.Konsole__KeyboardTranslator__Entry_setCommand(this.h, (C.int)(command))
}
func (this *Konsole__KeyboardTranslator__Entry) Text() []byte {
var _bytearray C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_text(this.h)
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) SetText(text []byte) {
text_alias := C.struct_miqt_string{}
if len(text) > 0 {
text_alias.data = (*C.char)(unsafe.Pointer(&text[0]))
} else {
text_alias.data = (*C.char)(unsafe.Pointer(nil))
}
text_alias.len = C.size_t(len(text))
C.Konsole__KeyboardTranslator__Entry_setText(this.h, text_alias)
}
func (this *Konsole__KeyboardTranslator__Entry) EscapedText() []byte {
var _bytearray C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_escapedText(this.h)
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) KeyCode() int {
return (int)(C.Konsole__KeyboardTranslator__Entry_keyCode(this.h))
}
func (this *Konsole__KeyboardTranslator__Entry) SetKeyCode(keyCode int) {
C.Konsole__KeyboardTranslator__Entry_setKeyCode(this.h, (C.int)(keyCode))
}
func (this *Konsole__KeyboardTranslator__Entry) Modifiers() qt.KeyboardModifier {
return (qt.KeyboardModifier)(C.Konsole__KeyboardTranslator__Entry_modifiers(this.h))
}
func (this *Konsole__KeyboardTranslator__Entry) ModifierMask() qt.KeyboardModifier {
return (qt.KeyboardModifier)(C.Konsole__KeyboardTranslator__Entry_modifierMask(this.h))
}
func (this *Konsole__KeyboardTranslator__Entry) SetModifiers(modifiers qt.KeyboardModifier) {
C.Konsole__KeyboardTranslator__Entry_setModifiers(this.h, (C.int)(modifiers))
}
func (this *Konsole__KeyboardTranslator__Entry) SetModifierMask(modifiers qt.KeyboardModifier) {
C.Konsole__KeyboardTranslator__Entry_setModifierMask(this.h, (C.int)(modifiers))
}
func (this *Konsole__KeyboardTranslator__Entry) State() Konsole__KeyboardTranslator__State {
return (Konsole__KeyboardTranslator__State)(C.Konsole__KeyboardTranslator__Entry_state(this.h))
}
func (this *Konsole__KeyboardTranslator__Entry) StateMask() Konsole__KeyboardTranslator__State {
return (Konsole__KeyboardTranslator__State)(C.Konsole__KeyboardTranslator__Entry_stateMask(this.h))
}
func (this *Konsole__KeyboardTranslator__Entry) SetState(state Konsole__KeyboardTranslator__State) {
C.Konsole__KeyboardTranslator__Entry_setState(this.h, (C.int)(state))
}
func (this *Konsole__KeyboardTranslator__Entry) SetStateMask(mask Konsole__KeyboardTranslator__State) {
C.Konsole__KeyboardTranslator__Entry_setStateMask(this.h, (C.int)(mask))
}
func (this *Konsole__KeyboardTranslator__Entry) ConditionToString() string {
var _ms C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_conditionToString(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) ResultToString() string {
var _ms C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_resultToString(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) Matches(keyCode int, modifiers qt.KeyboardModifier, flags Konsole__KeyboardTranslator__State) bool {
return (bool)(C.Konsole__KeyboardTranslator__Entry_matches(this.h, (C.int)(keyCode), (C.int)(modifiers), (C.int)(flags)))
}
func (this *Konsole__KeyboardTranslator__Entry) OperatorEqual(rhs *Konsole__KeyboardTranslator__Entry) bool {
return (bool)(C.Konsole__KeyboardTranslator__Entry_operatorEqual(this.h, rhs.cPointer()))
}
func (this *Konsole__KeyboardTranslator__Entry) TextWithExpandWildCards(expandWildCards bool) []byte {
var _bytearray C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_textWithExpandWildCards(this.h, (C.bool)(expandWildCards))
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) Text2(expandWildCards bool, modifiers qt.KeyboardModifier) []byte {
var _bytearray C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_text2(this.h, (C.bool)(expandWildCards), (C.int)(modifiers))
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) EscapedTextWithExpandWildCards(expandWildCards bool) []byte {
var _bytearray C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_escapedTextWithExpandWildCards(this.h, (C.bool)(expandWildCards))
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) EscapedText2(expandWildCards bool, modifiers qt.KeyboardModifier) []byte {
var _bytearray C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_escapedText2(this.h, (C.bool)(expandWildCards), (C.int)(modifiers))
_ret := C.GoBytes(unsafe.Pointer(_bytearray.data), C.int(int64(_bytearray.len)))
C.free(unsafe.Pointer(_bytearray.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) ResultToStringWithExpandWildCards(expandWildCards bool) string {
var _ms C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_resultToStringWithExpandWildCards(this.h, (C.bool)(expandWildCards))
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *Konsole__KeyboardTranslator__Entry) ResultToString2(expandWildCards bool, modifiers qt.KeyboardModifier) string {
var _ms C.struct_miqt_string = C.Konsole__KeyboardTranslator__Entry_resultToString2(this.h, (C.bool)(expandWildCards), (C.int)(modifiers))
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
// Delete this object from C++ memory.
func (this *Konsole__KeyboardTranslator__Entry) Delete() {
C.Konsole__KeyboardTranslator__Entry_delete(this.h)
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *Konsole__KeyboardTranslator__Entry) GoGC() {
runtime.SetFinalizer(this, func(this *Konsole__KeyboardTranslator__Entry) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

121
qt-restricted-extras/qtermwidget/gen_KeyboardTranslator.h Normal file
View File

@ -0,0 +1,121 @@
#pragma once
#ifndef MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_KEYBOARDTRANSLATOR_H
#define MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_KEYBOARDTRANSLATOR_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslator)
typedef Konsole::KeyboardTranslator Konsole__KeyboardTranslator;
#else
class Konsole__KeyboardTranslator;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslator__Entry)
typedef Konsole::KeyboardTranslator::Entry Konsole__KeyboardTranslator__Entry;
#else
class Konsole__KeyboardTranslator__Entry;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslatorManager)
typedef Konsole::KeyboardTranslatorManager Konsole__KeyboardTranslatorManager;
#else
class Konsole__KeyboardTranslatorManager;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslatorReader)
typedef Konsole::KeyboardTranslatorReader Konsole__KeyboardTranslatorReader;
#else
class Konsole__KeyboardTranslatorReader;
#endif
#if defined(WORKAROUND_INNER_CLASS_DEFINITION_Konsole__KeyboardTranslatorWriter)
typedef Konsole::KeyboardTranslatorWriter Konsole__KeyboardTranslatorWriter;
#else
class Konsole__KeyboardTranslatorWriter;
#endif
class QIODevice;
#else
typedef struct Konsole__KeyboardTranslator Konsole__KeyboardTranslator;
typedef struct Konsole__KeyboardTranslator__Entry Konsole__KeyboardTranslator__Entry;
typedef struct Konsole__KeyboardTranslatorManager Konsole__KeyboardTranslatorManager;
typedef struct Konsole__KeyboardTranslatorReader Konsole__KeyboardTranslatorReader;
typedef struct Konsole__KeyboardTranslatorWriter Konsole__KeyboardTranslatorWriter;
typedef struct QIODevice QIODevice;
#endif
Konsole__KeyboardTranslator* Konsole__KeyboardTranslator_new(struct miqt_string name);
Konsole__KeyboardTranslator* Konsole__KeyboardTranslator_new2(Konsole__KeyboardTranslator* param1);
struct miqt_string Konsole__KeyboardTranslator_name(const Konsole__KeyboardTranslator* self);
void Konsole__KeyboardTranslator_setName(Konsole__KeyboardTranslator* self, struct miqt_string name);
struct miqt_string Konsole__KeyboardTranslator_description(const Konsole__KeyboardTranslator* self);
void Konsole__KeyboardTranslator_setDescription(Konsole__KeyboardTranslator* self, struct miqt_string description);
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator_findEntry(const Konsole__KeyboardTranslator* self, int keyCode, int modifiers);
void Konsole__KeyboardTranslator_addEntry(Konsole__KeyboardTranslator* self, Konsole__KeyboardTranslator__Entry* entry);
void Konsole__KeyboardTranslator_replaceEntry(Konsole__KeyboardTranslator* self, Konsole__KeyboardTranslator__Entry* existing, Konsole__KeyboardTranslator__Entry* replacement);
void Konsole__KeyboardTranslator_removeEntry(Konsole__KeyboardTranslator* self, Konsole__KeyboardTranslator__Entry* entry);
struct miqt_array /* of Konsole__KeyboardTranslator__Entry* */ Konsole__KeyboardTranslator_entries(const Konsole__KeyboardTranslator* self);
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator_findEntry2(const Konsole__KeyboardTranslator* self, int keyCode, int modifiers, int state);
void Konsole__KeyboardTranslator_delete(Konsole__KeyboardTranslator* self);
Konsole__KeyboardTranslatorReader* Konsole__KeyboardTranslatorReader_new(QIODevice* source);
Konsole__KeyboardTranslatorReader* Konsole__KeyboardTranslatorReader_new2(Konsole__KeyboardTranslatorReader* param1);
struct miqt_string Konsole__KeyboardTranslatorReader_description(const Konsole__KeyboardTranslatorReader* self);
bool Konsole__KeyboardTranslatorReader_hasNextEntry(const Konsole__KeyboardTranslatorReader* self);
bool Konsole__KeyboardTranslatorReader_parseError(Konsole__KeyboardTranslatorReader* self);
void Konsole__KeyboardTranslatorReader_delete(Konsole__KeyboardTranslatorReader* self);
Konsole__KeyboardTranslatorWriter* Konsole__KeyboardTranslatorWriter_new(QIODevice* destination);
void Konsole__KeyboardTranslatorWriter_writeHeader(Konsole__KeyboardTranslatorWriter* self, struct miqt_string description);
void Konsole__KeyboardTranslatorWriter_delete(Konsole__KeyboardTranslatorWriter* self);
Konsole__KeyboardTranslatorManager* Konsole__KeyboardTranslatorManager_new();
void Konsole__KeyboardTranslatorManager_addTranslator(Konsole__KeyboardTranslatorManager* self, Konsole__KeyboardTranslator* translator);
bool Konsole__KeyboardTranslatorManager_deleteTranslator(Konsole__KeyboardTranslatorManager* self, struct miqt_string name);
Konsole__KeyboardTranslator* Konsole__KeyboardTranslatorManager_defaultTranslator(Konsole__KeyboardTranslatorManager* self);
Konsole__KeyboardTranslator* Konsole__KeyboardTranslatorManager_findTranslator(Konsole__KeyboardTranslatorManager* self, struct miqt_string name);
struct miqt_array /* of struct miqt_string */ Konsole__KeyboardTranslatorManager_allTranslators(Konsole__KeyboardTranslatorManager* self);
Konsole__KeyboardTranslatorManager* Konsole__KeyboardTranslatorManager_instance();
void Konsole__KeyboardTranslatorManager_delete(Konsole__KeyboardTranslatorManager* self);
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator__Entry_new();
Konsole__KeyboardTranslator__Entry* Konsole__KeyboardTranslator__Entry_new2(Konsole__KeyboardTranslator__Entry* param1);
bool Konsole__KeyboardTranslator__Entry_isNull(const Konsole__KeyboardTranslator__Entry* self);
int Konsole__KeyboardTranslator__Entry_command(const Konsole__KeyboardTranslator__Entry* self);
void Konsole__KeyboardTranslator__Entry_setCommand(Konsole__KeyboardTranslator__Entry* self, int command);
struct miqt_string Konsole__KeyboardTranslator__Entry_text(const Konsole__KeyboardTranslator__Entry* self);
void Konsole__KeyboardTranslator__Entry_setText(Konsole__KeyboardTranslator__Entry* self, struct miqt_string text);
struct miqt_string Konsole__KeyboardTranslator__Entry_escapedText(const Konsole__KeyboardTranslator__Entry* self);
int Konsole__KeyboardTranslator__Entry_keyCode(const Konsole__KeyboardTranslator__Entry* self);
void Konsole__KeyboardTranslator__Entry_setKeyCode(Konsole__KeyboardTranslator__Entry* self, int keyCode);
int Konsole__KeyboardTranslator__Entry_modifiers(const Konsole__KeyboardTranslator__Entry* self);
int Konsole__KeyboardTranslator__Entry_modifierMask(const Konsole__KeyboardTranslator__Entry* self);
void Konsole__KeyboardTranslator__Entry_setModifiers(Konsole__KeyboardTranslator__Entry* self, int modifiers);
void Konsole__KeyboardTranslator__Entry_setModifierMask(Konsole__KeyboardTranslator__Entry* self, int modifiers);
int Konsole__KeyboardTranslator__Entry_state(const Konsole__KeyboardTranslator__Entry* self);
int Konsole__KeyboardTranslator__Entry_stateMask(const Konsole__KeyboardTranslator__Entry* self);
void Konsole__KeyboardTranslator__Entry_setState(Konsole__KeyboardTranslator__Entry* self, int state);
void Konsole__KeyboardTranslator__Entry_setStateMask(Konsole__KeyboardTranslator__Entry* self, int mask);
struct miqt_string Konsole__KeyboardTranslator__Entry_conditionToString(const Konsole__KeyboardTranslator__Entry* self);
struct miqt_string Konsole__KeyboardTranslator__Entry_resultToString(const Konsole__KeyboardTranslator__Entry* self);
bool Konsole__KeyboardTranslator__Entry_matches(const Konsole__KeyboardTranslator__Entry* self, int keyCode, int modifiers, int flags);
bool Konsole__KeyboardTranslator__Entry_operatorEqual(const Konsole__KeyboardTranslator__Entry* self, Konsole__KeyboardTranslator__Entry* rhs);
struct miqt_string Konsole__KeyboardTranslator__Entry_textWithExpandWildCards(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards);
struct miqt_string Konsole__KeyboardTranslator__Entry_text2(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards, int modifiers);
struct miqt_string Konsole__KeyboardTranslator__Entry_escapedTextWithExpandWildCards(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards);
struct miqt_string Konsole__KeyboardTranslator__Entry_escapedText2(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards, int modifiers);
struct miqt_string Konsole__KeyboardTranslator__Entry_resultToStringWithExpandWildCards(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards);
struct miqt_string Konsole__KeyboardTranslator__Entry_resultToString2(const Konsole__KeyboardTranslator__Entry* self, bool expandWildCards, int modifiers);
void Konsole__KeyboardTranslator__Entry_delete(Konsole__KeyboardTranslator__Entry* self);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

4908
qt-restricted-extras/qtermwidget/gen_qtermwidget.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

3939
qt-restricted-extras/qtermwidget/gen_qtermwidget.go Normal file
View File

File diff suppressed because it is too large Load Diff

443
qt-restricted-extras/qtermwidget/gen_qtermwidget.h Normal file
View File

@ -0,0 +1,443 @@
#pragma once
#ifndef MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_QTERMWIDGET_H
#define MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_QTERMWIDGET_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
class QAction;
class QActionEvent;
class QChildEvent;
class QCloseEvent;
class QContextMenuEvent;
class QDragEnterEvent;
class QDragLeaveEvent;
class QDragMoveEvent;
class QDropEvent;
class QEvent;
class QFocusEvent;
class QFont;
class QHideEvent;
class QIODevice;
class QInputMethodEvent;
class QKeyEvent;
class QMetaMethod;
class QMetaObject;
class QMouseEvent;
class QMoveEvent;
class QObject;
class QPaintDevice;
class QPaintEngine;
class QPaintEvent;
class QPainter;
class QPoint;
class QResizeEvent;
class QShowEvent;
class QSize;
class QTabletEvent;
class QTermWidget;
class QTermWidgetInterface;
class QTextCodec;
class QTimerEvent;
class QUrl;
class QVariant;
class QWheelEvent;
class QWidget;
#else
typedef struct QAction QAction;
typedef struct QActionEvent QActionEvent;
typedef struct QChildEvent QChildEvent;
typedef struct QCloseEvent QCloseEvent;
typedef struct QContextMenuEvent QContextMenuEvent;
typedef struct QDragEnterEvent QDragEnterEvent;
typedef struct QDragLeaveEvent QDragLeaveEvent;
typedef struct QDragMoveEvent QDragMoveEvent;
typedef struct QDropEvent QDropEvent;
typedef struct QEvent QEvent;
typedef struct QFocusEvent QFocusEvent;
typedef struct QFont QFont;
typedef struct QHideEvent QHideEvent;
typedef struct QIODevice QIODevice;
typedef struct QInputMethodEvent QInputMethodEvent;
typedef struct QKeyEvent QKeyEvent;
typedef struct QMetaMethod QMetaMethod;
typedef struct QMetaObject QMetaObject;
typedef struct QMouseEvent QMouseEvent;
typedef struct QMoveEvent QMoveEvent;
typedef struct QObject QObject;
typedef struct QPaintDevice QPaintDevice;
typedef struct QPaintEngine QPaintEngine;
typedef struct QPaintEvent QPaintEvent;
typedef struct QPainter QPainter;
typedef struct QPoint QPoint;
typedef struct QResizeEvent QResizeEvent;
typedef struct QShowEvent QShowEvent;
typedef struct QSize QSize;
typedef struct QTabletEvent QTabletEvent;
typedef struct QTermWidget QTermWidget;
typedef struct QTermWidgetInterface QTermWidgetInterface;
typedef struct QTextCodec QTextCodec;
typedef struct QTimerEvent QTimerEvent;
typedef struct QUrl QUrl;
typedef struct QVariant QVariant;
typedef struct QWheelEvent QWheelEvent;
typedef struct QWidget QWidget;
#endif
QTermWidget* QTermWidget_new(QWidget* parent);
QTermWidget* QTermWidget_new2(int startnow);
QTermWidget* QTermWidget_new3();
QTermWidget* QTermWidget_new4(int startnow, QWidget* parent);
void QTermWidget_virtbase(QTermWidget* src, QWidget** outptr_QWidget, QTermWidgetInterface** outptr_QTermWidgetInterface);
QMetaObject* QTermWidget_metaObject(const QTermWidget* self);
void* QTermWidget_metacast(QTermWidget* self, const char* param1);
struct miqt_string QTermWidget_tr(const char* s);
struct miqt_string QTermWidget_trUtf8(const char* s);
QSize* QTermWidget_sizeHint(const QTermWidget* self);
void QTermWidget_setTerminalSizeHint(QTermWidget* self, bool enabled);
bool QTermWidget_terminalSizeHint(QTermWidget* self);
void QTermWidget_startShellProgram(QTermWidget* self);
void QTermWidget_startTerminalTeletype(QTermWidget* self);
int QTermWidget_getShellPID(QTermWidget* self);
void QTermWidget_changeDir(QTermWidget* self, struct miqt_string dir);
void QTermWidget_setTerminalFont(QTermWidget* self, QFont* font);
QFont* QTermWidget_getTerminalFont(QTermWidget* self);
void QTermWidget_setTerminalOpacity(QTermWidget* self, double level);
void QTermWidget_setTerminalBackgroundImage(QTermWidget* self, struct miqt_string backgroundImage);
void QTermWidget_setTerminalBackgroundMode(QTermWidget* self, int mode);
void QTermWidget_setEnvironment(QTermWidget* self, struct miqt_array /* of struct miqt_string */ environment);
void QTermWidget_setShellProgram(QTermWidget* self, struct miqt_string program);
void QTermWidget_setWorkingDirectory(QTermWidget* self, struct miqt_string dir);
struct miqt_string QTermWidget_workingDirectory(QTermWidget* self);
void QTermWidget_setArgs(QTermWidget* self, struct miqt_array /* of struct miqt_string */ args);
void QTermWidget_setTextCodec(QTermWidget* self, QTextCodec* codec);
void QTermWidget_setColorScheme(QTermWidget* self, struct miqt_string name);
struct miqt_array /* of struct miqt_string */ QTermWidget_getAvailableColorSchemes(QTermWidget* self);
struct miqt_array /* of struct miqt_string */ QTermWidget_availableColorSchemes();
void QTermWidget_addCustomColorSchemeDir(struct miqt_string custom_dir);
void QTermWidget_setHistorySize(QTermWidget* self, int lines);
int QTermWidget_historySize(const QTermWidget* self);
void QTermWidget_setScrollBarPosition(QTermWidget* self, int scrollBarPosition);
void QTermWidget_scrollToEnd(QTermWidget* self);
void QTermWidget_sendText(QTermWidget* self, struct miqt_string text);
void QTermWidget_sendKeyEvent(QTermWidget* self, QKeyEvent* e);
void QTermWidget_setFlowControlEnabled(QTermWidget* self, bool enabled);
bool QTermWidget_flowControlEnabled(QTermWidget* self);
void QTermWidget_setFlowControlWarningEnabled(QTermWidget* self, bool enabled);
struct miqt_array /* of struct miqt_string */ QTermWidget_availableKeyBindings();
struct miqt_string QTermWidget_keyBindings(QTermWidget* self);
void QTermWidget_setMotionAfterPasting(QTermWidget* self, int motionAfterPasting);
int QTermWidget_historyLinesCount(QTermWidget* self);
int QTermWidget_screenColumnsCount(QTermWidget* self);
int QTermWidget_screenLinesCount(QTermWidget* self);
void QTermWidget_setSelectionStart(QTermWidget* self, int row, int column);
void QTermWidget_setSelectionEnd(QTermWidget* self, int row, int column);
void QTermWidget_getSelectionStart(QTermWidget* self, int* row, int* column);
void QTermWidget_getSelectionEnd(QTermWidget* self, int* row, int* column);
struct miqt_string QTermWidget_selectedText(QTermWidget* self, bool preserveLineBreaks);
void QTermWidget_setMonitorActivity(QTermWidget* self, bool monitorActivity);
void QTermWidget_setMonitorSilence(QTermWidget* self, bool monitorSilence);
void QTermWidget_setSilenceTimeout(QTermWidget* self, int seconds);
struct miqt_array /* of QAction* */ QTermWidget_filterActions(QTermWidget* self, QPoint* position);
int QTermWidget_getPtySlaveFd(const QTermWidget* self);
void QTermWidget_setKeyboardCursorShape(QTermWidget* self, int shape);
void QTermWidget_setBlinkingCursor(QTermWidget* self, bool blink);
void QTermWidget_setBidiEnabled(QTermWidget* self, bool enabled);
bool QTermWidget_isBidiEnabled(QTermWidget* self);
void QTermWidget_setAutoClose(QTermWidget* self, bool autoClose);
struct miqt_string QTermWidget_title(const QTermWidget* self);
struct miqt_string QTermWidget_icon(const QTermWidget* self);
bool QTermWidget_isTitleChanged(const QTermWidget* self);
void QTermWidget_bracketText(QTermWidget* self, struct miqt_string text);
void QTermWidget_disableBracketedPasteMode(QTermWidget* self, bool disable);
bool QTermWidget_bracketedPasteModeIsDisabled(const QTermWidget* self);
void QTermWidget_setMargin(QTermWidget* self, int margin);
int QTermWidget_getMargin(const QTermWidget* self);
void QTermWidget_setDrawLineChars(QTermWidget* self, bool drawLineChars);
void QTermWidget_setBoldIntense(QTermWidget* self, bool boldIntense);
void QTermWidget_setConfirmMultilinePaste(QTermWidget* self, bool confirmMultilinePaste);
void QTermWidget_setTrimPastedTrailingNewlines(QTermWidget* self, bool trimPastedTrailingNewlines);
QTermWidgetInterface* QTermWidget_createWidget(const QTermWidget* self, int startnow);
void QTermWidget_finished(QTermWidget* self);
void QTermWidget_connect_finished(QTermWidget* self, intptr_t slot);
void QTermWidget_copyAvailable(QTermWidget* self, bool param1);
void QTermWidget_connect_copyAvailable(QTermWidget* self, intptr_t slot);
void QTermWidget_termGetFocus(QTermWidget* self);
void QTermWidget_connect_termGetFocus(QTermWidget* self, intptr_t slot);
void QTermWidget_termLostFocus(QTermWidget* self);
void QTermWidget_connect_termLostFocus(QTermWidget* self, intptr_t slot);
void QTermWidget_termKeyPressed(QTermWidget* self, QKeyEvent* param1);
void QTermWidget_connect_termKeyPressed(QTermWidget* self, intptr_t slot);
void QTermWidget_urlActivated(QTermWidget* self, QUrl* param1, bool fromContextMenu);
void QTermWidget_connect_urlActivated(QTermWidget* self, intptr_t slot);
void QTermWidget_bell(QTermWidget* self, struct miqt_string message);
void QTermWidget_connect_bell(QTermWidget* self, intptr_t slot);
void QTermWidget_activity(QTermWidget* self);
void QTermWidget_connect_activity(QTermWidget* self, intptr_t slot);
void QTermWidget_silence(QTermWidget* self);
void QTermWidget_connect_silence(QTermWidget* self, intptr_t slot);
void QTermWidget_sendData(QTermWidget* self, const char* param1, int param2);
void QTermWidget_connect_sendData(QTermWidget* self, intptr_t slot);
void QTermWidget_profileChanged(QTermWidget* self, struct miqt_string profile);
void QTermWidget_connect_profileChanged(QTermWidget* self, intptr_t slot);
void QTermWidget_titleChanged(QTermWidget* self);
void QTermWidget_connect_titleChanged(QTermWidget* self, intptr_t slot);
void QTermWidget_receivedData(QTermWidget* self, struct miqt_string text);
void QTermWidget_connect_receivedData(QTermWidget* self, intptr_t slot);
void QTermWidget_copyClipboard(QTermWidget* self);
void QTermWidget_pasteClipboard(QTermWidget* self);
void QTermWidget_pasteSelection(QTermWidget* self);
void QTermWidget_zoomIn(QTermWidget* self);
void QTermWidget_zoomOut(QTermWidget* self);
void QTermWidget_setSize(QTermWidget* self, QSize* size);
void QTermWidget_setKeyBindings(QTermWidget* self, struct miqt_string kb);
void QTermWidget_clear(QTermWidget* self);
void QTermWidget_toggleShowSearchBar(QTermWidget* self);
void QTermWidget_saveHistory(QTermWidget* self, QIODevice* device);
void QTermWidget_resizeEvent(QTermWidget* self, QResizeEvent* param1);
struct miqt_string QTermWidget_tr2(const char* s, const char* c);
struct miqt_string QTermWidget_tr3(const char* s, const char* c, int n);
struct miqt_string QTermWidget_trUtf82(const char* s, const char* c);
struct miqt_string QTermWidget_trUtf83(const char* s, const char* c, int n);
bool QTermWidget_override_virtual_sizeHint(void* self, intptr_t slot);
QSize* QTermWidget_virtualbase_sizeHint(const void* self);
bool QTermWidget_override_virtual_setTerminalSizeHint(void* self, intptr_t slot);
void QTermWidget_virtualbase_setTerminalSizeHint(void* self, bool enabled);
bool QTermWidget_override_virtual_terminalSizeHint(void* self, intptr_t slot);
bool QTermWidget_virtualbase_terminalSizeHint(void* self);
bool QTermWidget_override_virtual_startShellProgram(void* self, intptr_t slot);
void QTermWidget_virtualbase_startShellProgram(void* self);
bool QTermWidget_override_virtual_startTerminalTeletype(void* self, intptr_t slot);
void QTermWidget_virtualbase_startTerminalTeletype(void* self);
bool QTermWidget_override_virtual_getShellPID(void* self, intptr_t slot);
int QTermWidget_virtualbase_getShellPID(void* self);
bool QTermWidget_override_virtual_changeDir(void* self, intptr_t slot);
void QTermWidget_virtualbase_changeDir(void* self, struct miqt_string dir);
bool QTermWidget_override_virtual_setTerminalFont(void* self, intptr_t slot);
void QTermWidget_virtualbase_setTerminalFont(void* self, QFont* font);
bool QTermWidget_override_virtual_getTerminalFont(void* self, intptr_t slot);
QFont* QTermWidget_virtualbase_getTerminalFont(void* self);
bool QTermWidget_override_virtual_setTerminalOpacity(void* self, intptr_t slot);
void QTermWidget_virtualbase_setTerminalOpacity(void* self, double level);
bool QTermWidget_override_virtual_setTerminalBackgroundImage(void* self, intptr_t slot);
void QTermWidget_virtualbase_setTerminalBackgroundImage(void* self, struct miqt_string backgroundImage);
bool QTermWidget_override_virtual_setTerminalBackgroundMode(void* self, intptr_t slot);
void QTermWidget_virtualbase_setTerminalBackgroundMode(void* self, int mode);
bool QTermWidget_override_virtual_setEnvironment(void* self, intptr_t slot);
void QTermWidget_virtualbase_setEnvironment(void* self, struct miqt_array /* of struct miqt_string */ environment);
bool QTermWidget_override_virtual_setShellProgram(void* self, intptr_t slot);
void QTermWidget_virtualbase_setShellProgram(void* self, struct miqt_string program);
bool QTermWidget_override_virtual_setWorkingDirectory(void* self, intptr_t slot);
void QTermWidget_virtualbase_setWorkingDirectory(void* self, struct miqt_string dir);
bool QTermWidget_override_virtual_workingDirectory(void* self, intptr_t slot);
struct miqt_string QTermWidget_virtualbase_workingDirectory(void* self);
bool QTermWidget_override_virtual_setArgs(void* self, intptr_t slot);
void QTermWidget_virtualbase_setArgs(void* self, struct miqt_array /* of struct miqt_string */ args);
bool QTermWidget_override_virtual_setTextCodec(void* self, intptr_t slot);
void QTermWidget_virtualbase_setTextCodec(void* self, QTextCodec* codec);
bool QTermWidget_override_virtual_setColorScheme(void* self, intptr_t slot);
void QTermWidget_virtualbase_setColorScheme(void* self, struct miqt_string name);
bool QTermWidget_override_virtual_getAvailableColorSchemes(void* self, intptr_t slot);
struct miqt_array /* of struct miqt_string */ QTermWidget_virtualbase_getAvailableColorSchemes(void* self);
bool QTermWidget_override_virtual_setHistorySize(void* self, intptr_t slot);
void QTermWidget_virtualbase_setHistorySize(void* self, int lines);
bool QTermWidget_override_virtual_historySize(void* self, intptr_t slot);
int QTermWidget_virtualbase_historySize(const void* self);
bool QTermWidget_override_virtual_setScrollBarPosition(void* self, intptr_t slot);
void QTermWidget_virtualbase_setScrollBarPosition(void* self, int scrollBarPosition);
bool QTermWidget_override_virtual_scrollToEnd(void* self, intptr_t slot);
void QTermWidget_virtualbase_scrollToEnd(void* self);
bool QTermWidget_override_virtual_sendText(void* self, intptr_t slot);
void QTermWidget_virtualbase_sendText(void* self, struct miqt_string text);
bool QTermWidget_override_virtual_sendKeyEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_sendKeyEvent(void* self, QKeyEvent* e);
bool QTermWidget_override_virtual_setFlowControlEnabled(void* self, intptr_t slot);
void QTermWidget_virtualbase_setFlowControlEnabled(void* self, bool enabled);
bool QTermWidget_override_virtual_flowControlEnabled(void* self, intptr_t slot);
bool QTermWidget_virtualbase_flowControlEnabled(void* self);
bool QTermWidget_override_virtual_setFlowControlWarningEnabled(void* self, intptr_t slot);
void QTermWidget_virtualbase_setFlowControlWarningEnabled(void* self, bool enabled);
bool QTermWidget_override_virtual_keyBindings(void* self, intptr_t slot);
struct miqt_string QTermWidget_virtualbase_keyBindings(void* self);
bool QTermWidget_override_virtual_setMotionAfterPasting(void* self, intptr_t slot);
void QTermWidget_virtualbase_setMotionAfterPasting(void* self, int motionAfterPasting);
bool QTermWidget_override_virtual_historyLinesCount(void* self, intptr_t slot);
int QTermWidget_virtualbase_historyLinesCount(void* self);
bool QTermWidget_override_virtual_screenColumnsCount(void* self, intptr_t slot);
int QTermWidget_virtualbase_screenColumnsCount(void* self);
bool QTermWidget_override_virtual_screenLinesCount(void* self, intptr_t slot);
int QTermWidget_virtualbase_screenLinesCount(void* self);
bool QTermWidget_override_virtual_setSelectionStart(void* self, intptr_t slot);
void QTermWidget_virtualbase_setSelectionStart(void* self, int row, int column);
bool QTermWidget_override_virtual_setSelectionEnd(void* self, intptr_t slot);
void QTermWidget_virtualbase_setSelectionEnd(void* self, int row, int column);
bool QTermWidget_override_virtual_getSelectionStart(void* self, intptr_t slot);
void QTermWidget_virtualbase_getSelectionStart(void* self, int* row, int* column);
bool QTermWidget_override_virtual_getSelectionEnd(void* self, intptr_t slot);
void QTermWidget_virtualbase_getSelectionEnd(void* self, int* row, int* column);
bool QTermWidget_override_virtual_selectedText(void* self, intptr_t slot);
struct miqt_string QTermWidget_virtualbase_selectedText(void* self, bool preserveLineBreaks);
bool QTermWidget_override_virtual_setMonitorActivity(void* self, intptr_t slot);
void QTermWidget_virtualbase_setMonitorActivity(void* self, bool monitorActivity);
bool QTermWidget_override_virtual_setMonitorSilence(void* self, intptr_t slot);
void QTermWidget_virtualbase_setMonitorSilence(void* self, bool monitorSilence);
bool QTermWidget_override_virtual_setSilenceTimeout(void* self, intptr_t slot);
void QTermWidget_virtualbase_setSilenceTimeout(void* self, int seconds);
bool QTermWidget_override_virtual_filterActions(void* self, intptr_t slot);
struct miqt_array /* of QAction* */ QTermWidget_virtualbase_filterActions(void* self, QPoint* position);
bool QTermWidget_override_virtual_getPtySlaveFd(void* self, intptr_t slot);
int QTermWidget_virtualbase_getPtySlaveFd(const void* self);
bool QTermWidget_override_virtual_setBlinkingCursor(void* self, intptr_t slot);
void QTermWidget_virtualbase_setBlinkingCursor(void* self, bool blink);
bool QTermWidget_override_virtual_setBidiEnabled(void* self, intptr_t slot);
void QTermWidget_virtualbase_setBidiEnabled(void* self, bool enabled);
bool QTermWidget_override_virtual_isBidiEnabled(void* self, intptr_t slot);
bool QTermWidget_virtualbase_isBidiEnabled(void* self);
bool QTermWidget_override_virtual_setAutoClose(void* self, intptr_t slot);
void QTermWidget_virtualbase_setAutoClose(void* self, bool autoClose);
bool QTermWidget_override_virtual_title(void* self, intptr_t slot);
struct miqt_string QTermWidget_virtualbase_title(const void* self);
bool QTermWidget_override_virtual_icon(void* self, intptr_t slot);
struct miqt_string QTermWidget_virtualbase_icon(const void* self);
bool QTermWidget_override_virtual_isTitleChanged(void* self, intptr_t slot);
bool QTermWidget_virtualbase_isTitleChanged(const void* self);
bool QTermWidget_override_virtual_bracketText(void* self, intptr_t slot);
void QTermWidget_virtualbase_bracketText(void* self, struct miqt_string text);
bool QTermWidget_override_virtual_disableBracketedPasteMode(void* self, intptr_t slot);
void QTermWidget_virtualbase_disableBracketedPasteMode(void* self, bool disable);
bool QTermWidget_override_virtual_bracketedPasteModeIsDisabled(void* self, intptr_t slot);
bool QTermWidget_virtualbase_bracketedPasteModeIsDisabled(const void* self);
bool QTermWidget_override_virtual_setMargin(void* self, intptr_t slot);
void QTermWidget_virtualbase_setMargin(void* self, int margin);
bool QTermWidget_override_virtual_getMargin(void* self, intptr_t slot);
int QTermWidget_virtualbase_getMargin(const void* self);
bool QTermWidget_override_virtual_setDrawLineChars(void* self, intptr_t slot);
void QTermWidget_virtualbase_setDrawLineChars(void* self, bool drawLineChars);
bool QTermWidget_override_virtual_setBoldIntense(void* self, intptr_t slot);
void QTermWidget_virtualbase_setBoldIntense(void* self, bool boldIntense);
bool QTermWidget_override_virtual_setConfirmMultilinePaste(void* self, intptr_t slot);
void QTermWidget_virtualbase_setConfirmMultilinePaste(void* self, bool confirmMultilinePaste);
bool QTermWidget_override_virtual_setTrimPastedTrailingNewlines(void* self, intptr_t slot);
void QTermWidget_virtualbase_setTrimPastedTrailingNewlines(void* self, bool trimPastedTrailingNewlines);
bool QTermWidget_override_virtual_createWidget(void* self, intptr_t slot);
QTermWidgetInterface* QTermWidget_virtualbase_createWidget(const void* self, int startnow);
bool QTermWidget_override_virtual_resizeEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_resizeEvent(void* self, QResizeEvent* param1);
bool QTermWidget_override_virtual_devType(void* self, intptr_t slot);
int QTermWidget_virtualbase_devType(const void* self);
bool QTermWidget_override_virtual_setVisible(void* self, intptr_t slot);
void QTermWidget_virtualbase_setVisible(void* self, bool visible);
bool QTermWidget_override_virtual_minimumSizeHint(void* self, intptr_t slot);
QSize* QTermWidget_virtualbase_minimumSizeHint(const void* self);
bool QTermWidget_override_virtual_heightForWidth(void* self, intptr_t slot);
int QTermWidget_virtualbase_heightForWidth(const void* self, int param1);
bool QTermWidget_override_virtual_hasHeightForWidth(void* self, intptr_t slot);
bool QTermWidget_virtualbase_hasHeightForWidth(const void* self);
bool QTermWidget_override_virtual_paintEngine(void* self, intptr_t slot);
QPaintEngine* QTermWidget_virtualbase_paintEngine(const void* self);
bool QTermWidget_override_virtual_event(void* self, intptr_t slot);
bool QTermWidget_virtualbase_event(void* self, QEvent* event);
bool QTermWidget_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_mousePressEvent(void* self, QMouseEvent* event);
bool QTermWidget_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_mouseReleaseEvent(void* self, QMouseEvent* event);
bool QTermWidget_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_mouseDoubleClickEvent(void* self, QMouseEvent* event);
bool QTermWidget_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_mouseMoveEvent(void* self, QMouseEvent* event);
bool QTermWidget_override_virtual_wheelEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_wheelEvent(void* self, QWheelEvent* event);
bool QTermWidget_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QTermWidget_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QTermWidget_override_virtual_focusInEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QTermWidget_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QTermWidget_override_virtual_enterEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_enterEvent(void* self, QEvent* event);
bool QTermWidget_override_virtual_leaveEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_leaveEvent(void* self, QEvent* event);
bool QTermWidget_override_virtual_paintEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_paintEvent(void* self, QPaintEvent* event);
bool QTermWidget_override_virtual_moveEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_moveEvent(void* self, QMoveEvent* event);
bool QTermWidget_override_virtual_closeEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_closeEvent(void* self, QCloseEvent* event);
bool QTermWidget_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_contextMenuEvent(void* self, QContextMenuEvent* event);
bool QTermWidget_override_virtual_tabletEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_tabletEvent(void* self, QTabletEvent* event);
bool QTermWidget_override_virtual_actionEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_actionEvent(void* self, QActionEvent* event);
bool QTermWidget_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_dragEnterEvent(void* self, QDragEnterEvent* event);
bool QTermWidget_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_dragMoveEvent(void* self, QDragMoveEvent* event);
bool QTermWidget_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_dragLeaveEvent(void* self, QDragLeaveEvent* event);
bool QTermWidget_override_virtual_dropEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_dropEvent(void* self, QDropEvent* event);
bool QTermWidget_override_virtual_showEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_showEvent(void* self, QShowEvent* event);
bool QTermWidget_override_virtual_hideEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_hideEvent(void* self, QHideEvent* event);
bool QTermWidget_override_virtual_nativeEvent(void* self, intptr_t slot);
bool QTermWidget_virtualbase_nativeEvent(void* self, struct miqt_string eventType, void* message, long* result);
bool QTermWidget_override_virtual_changeEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_changeEvent(void* self, QEvent* param1);
bool QTermWidget_override_virtual_metric(void* self, intptr_t slot);
int QTermWidget_virtualbase_metric(const void* self, int param1);
bool QTermWidget_override_virtual_initPainter(void* self, intptr_t slot);
void QTermWidget_virtualbase_initPainter(const void* self, QPainter* painter);
bool QTermWidget_override_virtual_redirected(void* self, intptr_t slot);
QPaintDevice* QTermWidget_virtualbase_redirected(const void* self, QPoint* offset);
bool QTermWidget_override_virtual_sharedPainter(void* self, intptr_t slot);
QPainter* QTermWidget_virtualbase_sharedPainter(const void* self);
bool QTermWidget_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* param1);
bool QTermWidget_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QTermWidget_virtualbase_inputMethodQuery(const void* self, int param1);
bool QTermWidget_override_virtual_focusNextPrevChild(void* self, intptr_t slot);
bool QTermWidget_virtualbase_focusNextPrevChild(void* self, bool next);
bool QTermWidget_override_virtual_eventFilter(void* self, intptr_t slot);
bool QTermWidget_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
bool QTermWidget_override_virtual_timerEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_timerEvent(void* self, QTimerEvent* event);
bool QTermWidget_override_virtual_childEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_childEvent(void* self, QChildEvent* event);
bool QTermWidget_override_virtual_customEvent(void* self, intptr_t slot);
void QTermWidget_virtualbase_customEvent(void* self, QEvent* event);
bool QTermWidget_override_virtual_connectNotify(void* self, intptr_t slot);
void QTermWidget_virtualbase_connectNotify(void* self, QMetaMethod* signal);
bool QTermWidget_override_virtual_disconnectNotify(void* self, intptr_t slot);
void QTermWidget_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
void QTermWidget_protectedbase_sessionFinished(bool* _dynamic_cast_ok, void* self);
void QTermWidget_protectedbase_selectionChanged(bool* _dynamic_cast_ok, void* self, bool textSelected);
void QTermWidget_protectedbase_updateMicroFocus(bool* _dynamic_cast_ok, void* self);
void QTermWidget_protectedbase_create(bool* _dynamic_cast_ok, void* self);
void QTermWidget_protectedbase_destroy(bool* _dynamic_cast_ok, void* self);
bool QTermWidget_protectedbase_focusNextChild(bool* _dynamic_cast_ok, void* self);
bool QTermWidget_protectedbase_focusPreviousChild(bool* _dynamic_cast_ok, void* self);
QObject* QTermWidget_protectedbase_sender(bool* _dynamic_cast_ok, const void* self);
int QTermWidget_protectedbase_senderSignalIndex(bool* _dynamic_cast_ok, const void* self);
int QTermWidget_protectedbase_receivers(bool* _dynamic_cast_ok, const void* self, const char* signal);
bool QTermWidget_protectedbase_isSignalConnected(bool* _dynamic_cast_ok, const void* self, QMetaMethod* signal);
void QTermWidget_delete(QTermWidget* self);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

350
qt-restricted-extras/qtermwidget/gen_qtermwidget_interface.cpp Normal file
View File

@ -0,0 +1,350 @@
#include <QAction>
#include <QFont>
#include <QKeyEvent>
#include <QList>
#include <QPoint>
#include <QString>
#include <QByteArray>
#include <cstring>
#include <QTermWidgetInterface>
#include <QTextCodec>
#include <qtermwidget_interface.h>
#include "gen_qtermwidget_interface.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
} /* extern C */
#endif
void QTermWidgetInterface_setTerminalSizeHint(QTermWidgetInterface* self, bool enabled) {
self->setTerminalSizeHint(enabled);
}
bool QTermWidgetInterface_terminalSizeHint(QTermWidgetInterface* self) {
return self->terminalSizeHint();
}
void QTermWidgetInterface_startShellProgram(QTermWidgetInterface* self) {
self->startShellProgram();
}
void QTermWidgetInterface_startTerminalTeletype(QTermWidgetInterface* self) {
self->startTerminalTeletype();
}
int QTermWidgetInterface_getShellPID(QTermWidgetInterface* self) {
return self->getShellPID();
}
void QTermWidgetInterface_changeDir(QTermWidgetInterface* self, struct miqt_string dir) {
QString dir_QString = QString::fromUtf8(dir.data, dir.len);
self->changeDir(dir_QString);
}
void QTermWidgetInterface_setTerminalFont(QTermWidgetInterface* self, QFont* font) {
self->setTerminalFont(*font);
}
QFont* QTermWidgetInterface_getTerminalFont(QTermWidgetInterface* self) {
return new QFont(self->getTerminalFont());
}
void QTermWidgetInterface_setTerminalOpacity(QTermWidgetInterface* self, double level) {
self->setTerminalOpacity(static_cast<qreal>(level));
}
void QTermWidgetInterface_setTerminalBackgroundImage(QTermWidgetInterface* self, struct miqt_string backgroundImage) {
QString backgroundImage_QString = QString::fromUtf8(backgroundImage.data, backgroundImage.len);
self->setTerminalBackgroundImage(backgroundImage_QString);
}
void QTermWidgetInterface_setTerminalBackgroundMode(QTermWidgetInterface* self, int mode) {
self->setTerminalBackgroundMode(static_cast<int>(mode));
}
void QTermWidgetInterface_setEnvironment(QTermWidgetInterface* self, struct miqt_array /* of struct miqt_string */ environment) {
QStringList environment_QList;
environment_QList.reserve(environment.len);
struct miqt_string* environment_arr = static_cast<struct miqt_string*>(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);
}
self->setEnvironment(environment_QList);
}
void QTermWidgetInterface_setShellProgram(QTermWidgetInterface* self, struct miqt_string program) {
QString program_QString = QString::fromUtf8(program.data, program.len);
self->setShellProgram(program_QString);
}
void QTermWidgetInterface_setWorkingDirectory(QTermWidgetInterface* self, struct miqt_string dir) {
QString dir_QString = QString::fromUtf8(dir.data, dir.len);
self->setWorkingDirectory(dir_QString);
}
struct miqt_string QTermWidgetInterface_workingDirectory(QTermWidgetInterface* self) {
QString _ret = self->workingDirectory();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
void QTermWidgetInterface_setArgs(QTermWidgetInterface* self, struct miqt_array /* of struct miqt_string */ args) {
QStringList args_QList;
args_QList.reserve(args.len);
struct miqt_string* args_arr = static_cast<struct miqt_string*>(args.data);
for(size_t i = 0; i < args.len; ++i) {
QString args_arr_i_QString = QString::fromUtf8(args_arr[i].data, args_arr[i].len);
args_QList.push_back(args_arr_i_QString);
}
self->setArgs(args_QList);
}
void QTermWidgetInterface_setTextCodec(QTermWidgetInterface* self, QTextCodec* codec) {
self->setTextCodec(codec);
}
void QTermWidgetInterface_setColorScheme(QTermWidgetInterface* self, struct miqt_string name) {
QString name_QString = QString::fromUtf8(name.data, name.len);
self->setColorScheme(name_QString);
}
struct miqt_array /* of struct miqt_string */ QTermWidgetInterface_getAvailableColorSchemes(QTermWidgetInterface* self) {
QStringList _ret = self->getAvailableColorSchemes();
// Convert QList<> from C++ memory to manually-managed C memory
struct miqt_string* _arr = static_cast<struct miqt_string*>(malloc(sizeof(struct miqt_string) * _ret.length()));
for (size_t i = 0, e = _ret.length(); i < e; ++i) {
QString _lv_ret = _ret[i];
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _lv_b = _lv_ret.toUtf8();
struct miqt_string _lv_ms;
_lv_ms.len = _lv_b.length();
_lv_ms.data = static_cast<char*>(malloc(_lv_ms.len));
memcpy(_lv_ms.data, _lv_b.data(), _lv_ms.len);
_arr[i] = _lv_ms;
}
struct miqt_array _out;
_out.len = _ret.length();
_out.data = static_cast<void*>(_arr);
return _out;
}
void QTermWidgetInterface_setHistorySize(QTermWidgetInterface* self, int lines) {
self->setHistorySize(static_cast<int>(lines));
}
int QTermWidgetInterface_historySize(const QTermWidgetInterface* self) {
return self->historySize();
}
void QTermWidgetInterface_setScrollBarPosition(QTermWidgetInterface* self, int scrollBarPosition) {
self->setScrollBarPosition(static_cast<QTermWidgetInterface::ScrollBarPosition>(scrollBarPosition));
}
void QTermWidgetInterface_scrollToEnd(QTermWidgetInterface* self) {
self->scrollToEnd();
}
void QTermWidgetInterface_sendText(QTermWidgetInterface* self, struct miqt_string text) {
QString text_QString = QString::fromUtf8(text.data, text.len);
self->sendText(text_QString);
}
void QTermWidgetInterface_sendKeyEvent(QTermWidgetInterface* self, QKeyEvent* e) {
self->sendKeyEvent(e);
}
void QTermWidgetInterface_setFlowControlEnabled(QTermWidgetInterface* self, bool enabled) {
self->setFlowControlEnabled(enabled);
}
bool QTermWidgetInterface_flowControlEnabled(QTermWidgetInterface* self) {
return self->flowControlEnabled();
}
void QTermWidgetInterface_setFlowControlWarningEnabled(QTermWidgetInterface* self, bool enabled) {
self->setFlowControlWarningEnabled(enabled);
}
struct miqt_string QTermWidgetInterface_keyBindings(QTermWidgetInterface* self) {
QString _ret = self->keyBindings();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
void QTermWidgetInterface_setMotionAfterPasting(QTermWidgetInterface* self, int motionAfterPasting) {
self->setMotionAfterPasting(static_cast<int>(motionAfterPasting));
}
int QTermWidgetInterface_historyLinesCount(QTermWidgetInterface* self) {
return self->historyLinesCount();
}
int QTermWidgetInterface_screenColumnsCount(QTermWidgetInterface* self) {
return self->screenColumnsCount();
}
int QTermWidgetInterface_screenLinesCount(QTermWidgetInterface* self) {
return self->screenLinesCount();
}
void QTermWidgetInterface_setSelectionStart(QTermWidgetInterface* self, int row, int column) {
self->setSelectionStart(static_cast<int>(row), static_cast<int>(column));
}
void QTermWidgetInterface_setSelectionEnd(QTermWidgetInterface* self, int row, int column) {
self->setSelectionEnd(static_cast<int>(row), static_cast<int>(column));
}
void QTermWidgetInterface_getSelectionStart(QTermWidgetInterface* self, int* row, int* column) {
self->getSelectionStart(static_cast<int&>(*row), static_cast<int&>(*column));
}
void QTermWidgetInterface_getSelectionEnd(QTermWidgetInterface* self, int* row, int* column) {
self->getSelectionEnd(static_cast<int&>(*row), static_cast<int&>(*column));
}
struct miqt_string QTermWidgetInterface_selectedText(QTermWidgetInterface* self, bool preserveLineBreaks) {
QString _ret = self->selectedText(preserveLineBreaks);
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
void QTermWidgetInterface_setMonitorActivity(QTermWidgetInterface* self, bool monitorActivity) {
self->setMonitorActivity(monitorActivity);
}
void QTermWidgetInterface_setMonitorSilence(QTermWidgetInterface* self, bool monitorSilence) {
self->setMonitorSilence(monitorSilence);
}
void QTermWidgetInterface_setSilenceTimeout(QTermWidgetInterface* self, int seconds) {
self->setSilenceTimeout(static_cast<int>(seconds));
}
struct miqt_array /* of QAction* */ QTermWidgetInterface_filterActions(QTermWidgetInterface* self, QPoint* position) {
QList<QAction *> _ret = self->filterActions(*position);
// Convert QList<> from C++ memory to manually-managed C memory
QAction** _arr = static_cast<QAction**>(malloc(sizeof(QAction*) * _ret.length()));
for (size_t i = 0, e = _ret.length(); i < e; ++i) {
_arr[i] = _ret[i];
}
struct miqt_array _out;
_out.len = _ret.length();
_out.data = static_cast<void*>(_arr);
return _out;
}
int QTermWidgetInterface_getPtySlaveFd(const QTermWidgetInterface* self) {
return self->getPtySlaveFd();
}
void QTermWidgetInterface_setBlinkingCursor(QTermWidgetInterface* self, bool blink) {
self->setBlinkingCursor(blink);
}
void QTermWidgetInterface_setBidiEnabled(QTermWidgetInterface* self, bool enabled) {
self->setBidiEnabled(enabled);
}
bool QTermWidgetInterface_isBidiEnabled(QTermWidgetInterface* self) {
return self->isBidiEnabled();
}
void QTermWidgetInterface_setAutoClose(QTermWidgetInterface* self, bool autoClose) {
self->setAutoClose(autoClose);
}
struct miqt_string QTermWidgetInterface_title(const QTermWidgetInterface* self) {
QString _ret = self->title();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
struct miqt_string QTermWidgetInterface_icon(const QTermWidgetInterface* self) {
QString _ret = self->icon();
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret.toUtf8();
struct miqt_string _ms;
_ms.len = _b.length();
_ms.data = static_cast<char*>(malloc(_ms.len));
memcpy(_ms.data, _b.data(), _ms.len);
return _ms;
}
bool QTermWidgetInterface_isTitleChanged(const QTermWidgetInterface* self) {
return self->isTitleChanged();
}
void QTermWidgetInterface_bracketText(QTermWidgetInterface* self, struct miqt_string text) {
QString text_QString = QString::fromUtf8(text.data, text.len);
self->bracketText(text_QString);
}
void QTermWidgetInterface_disableBracketedPasteMode(QTermWidgetInterface* self, bool disable) {
self->disableBracketedPasteMode(disable);
}
bool QTermWidgetInterface_bracketedPasteModeIsDisabled(const QTermWidgetInterface* self) {
return self->bracketedPasteModeIsDisabled();
}
void QTermWidgetInterface_setMargin(QTermWidgetInterface* self, int margin) {
self->setMargin(static_cast<int>(margin));
}
int QTermWidgetInterface_getMargin(const QTermWidgetInterface* self) {
return self->getMargin();
}
void QTermWidgetInterface_setDrawLineChars(QTermWidgetInterface* self, bool drawLineChars) {
self->setDrawLineChars(drawLineChars);
}
void QTermWidgetInterface_setBoldIntense(QTermWidgetInterface* self, bool boldIntense) {
self->setBoldIntense(boldIntense);
}
void QTermWidgetInterface_setConfirmMultilinePaste(QTermWidgetInterface* self, bool confirmMultilinePaste) {
self->setConfirmMultilinePaste(confirmMultilinePaste);
}
void QTermWidgetInterface_setTrimPastedTrailingNewlines(QTermWidgetInterface* self, bool trimPastedTrailingNewlines) {
self->setTrimPastedTrailingNewlines(trimPastedTrailingNewlines);
}
QTermWidgetInterface* QTermWidgetInterface_createWidget(const QTermWidgetInterface* self, int startnow) {
return self->createWidget(static_cast<int>(startnow));
}
void QTermWidgetInterface_operatorAssign(QTermWidgetInterface* self, QTermWidgetInterface* param1) {
self->operator=(*param1);
}
void QTermWidgetInterface_delete(QTermWidgetInterface* self) {
delete self;
}

393
qt-restricted-extras/qtermwidget/gen_qtermwidget_interface.go Normal file
View File

@ -0,0 +1,393 @@
package qtermwidget
/*
#include "gen_qtermwidget_interface.h"
#include <stdlib.h>
*/
import "C"
import (
"github.com/mappu/miqt/qt"
"runtime"
"unsafe"
)
type QTermWidgetInterface__ScrollBarPosition int
const (
QTermWidgetInterface__NoScrollBar QTermWidgetInterface__ScrollBarPosition = 0
QTermWidgetInterface__ScrollBarLeft QTermWidgetInterface__ScrollBarPosition = 1
QTermWidgetInterface__ScrollBarRight QTermWidgetInterface__ScrollBarPosition = 2
)
type QTermWidgetInterface struct {
h *C.QTermWidgetInterface
}
func (this *QTermWidgetInterface) cPointer() *C.QTermWidgetInterface {
if this == nil {
return nil
}
return this.h
}
func (this *QTermWidgetInterface) UnsafePointer() unsafe.Pointer {
if this == nil {
return nil
}
return unsafe.Pointer(this.h)
}
// newQTermWidgetInterface constructs the type using only CGO pointers.
func newQTermWidgetInterface(h *C.QTermWidgetInterface) *QTermWidgetInterface {
if h == nil {
return nil
}
return &QTermWidgetInterface{h: h}
}
// UnsafeNewQTermWidgetInterface constructs the type using only unsafe pointers.
func UnsafeNewQTermWidgetInterface(h unsafe.Pointer) *QTermWidgetInterface {
return newQTermWidgetInterface((*C.QTermWidgetInterface)(h))
}
func (this *QTermWidgetInterface) SetTerminalSizeHint(enabled bool) {
C.QTermWidgetInterface_setTerminalSizeHint(this.h, (C.bool)(enabled))
}
func (this *QTermWidgetInterface) TerminalSizeHint() bool {
return (bool)(C.QTermWidgetInterface_terminalSizeHint(this.h))
}
func (this *QTermWidgetInterface) StartShellProgram() {
C.QTermWidgetInterface_startShellProgram(this.h)
}
func (this *QTermWidgetInterface) StartTerminalTeletype() {
C.QTermWidgetInterface_startTerminalTeletype(this.h)
}
func (this *QTermWidgetInterface) GetShellPID() int {
return (int)(C.QTermWidgetInterface_getShellPID(this.h))
}
func (this *QTermWidgetInterface) ChangeDir(dir string) {
dir_ms := C.struct_miqt_string{}
dir_ms.data = C.CString(dir)
dir_ms.len = C.size_t(len(dir))
defer C.free(unsafe.Pointer(dir_ms.data))
C.QTermWidgetInterface_changeDir(this.h, dir_ms)
}
func (this *QTermWidgetInterface) SetTerminalFont(font *qt.QFont) {
C.QTermWidgetInterface_setTerminalFont(this.h, (*C.QFont)(font.UnsafePointer()))
}
func (this *QTermWidgetInterface) GetTerminalFont() *qt.QFont {
_goptr := qt.UnsafeNewQFont(unsafe.Pointer(C.QTermWidgetInterface_getTerminalFont(this.h)))
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
return _goptr
}
func (this *QTermWidgetInterface) SetTerminalOpacity(level float64) {
C.QTermWidgetInterface_setTerminalOpacity(this.h, (C.double)(level))
}
func (this *QTermWidgetInterface) SetTerminalBackgroundImage(backgroundImage string) {
backgroundImage_ms := C.struct_miqt_string{}
backgroundImage_ms.data = C.CString(backgroundImage)
backgroundImage_ms.len = C.size_t(len(backgroundImage))
defer C.free(unsafe.Pointer(backgroundImage_ms.data))
C.QTermWidgetInterface_setTerminalBackgroundImage(this.h, backgroundImage_ms)
}
func (this *QTermWidgetInterface) SetTerminalBackgroundMode(mode int) {
C.QTermWidgetInterface_setTerminalBackgroundMode(this.h, (C.int)(mode))
}
func (this *QTermWidgetInterface) SetEnvironment(environment []string) {
environment_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(environment))))
defer C.free(unsafe.Pointer(environment_CArray))
for i := range environment {
environment_i_ms := C.struct_miqt_string{}
environment_i_ms.data = C.CString(environment[i])
environment_i_ms.len = C.size_t(len(environment[i]))
defer C.free(unsafe.Pointer(environment_i_ms.data))
environment_CArray[i] = environment_i_ms
}
environment_ma := C.struct_miqt_array{len: C.size_t(len(environment)), data: unsafe.Pointer(environment_CArray)}
C.QTermWidgetInterface_setEnvironment(this.h, environment_ma)
}
func (this *QTermWidgetInterface) SetShellProgram(program string) {
program_ms := C.struct_miqt_string{}
program_ms.data = C.CString(program)
program_ms.len = C.size_t(len(program))
defer C.free(unsafe.Pointer(program_ms.data))
C.QTermWidgetInterface_setShellProgram(this.h, program_ms)
}
func (this *QTermWidgetInterface) SetWorkingDirectory(dir string) {
dir_ms := C.struct_miqt_string{}
dir_ms.data = C.CString(dir)
dir_ms.len = C.size_t(len(dir))
defer C.free(unsafe.Pointer(dir_ms.data))
C.QTermWidgetInterface_setWorkingDirectory(this.h, dir_ms)
}
func (this *QTermWidgetInterface) WorkingDirectory() string {
var _ms C.struct_miqt_string = C.QTermWidgetInterface_workingDirectory(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QTermWidgetInterface) SetArgs(args []string) {
args_CArray := (*[0xffff]C.struct_miqt_string)(C.malloc(C.size_t(int(unsafe.Sizeof(C.struct_miqt_string{})) * len(args))))
defer C.free(unsafe.Pointer(args_CArray))
for i := range args {
args_i_ms := C.struct_miqt_string{}
args_i_ms.data = C.CString(args[i])
args_i_ms.len = C.size_t(len(args[i]))
defer C.free(unsafe.Pointer(args_i_ms.data))
args_CArray[i] = args_i_ms
}
args_ma := C.struct_miqt_array{len: C.size_t(len(args)), data: unsafe.Pointer(args_CArray)}
C.QTermWidgetInterface_setArgs(this.h, args_ma)
}
func (this *QTermWidgetInterface) SetTextCodec(codec *qt.QTextCodec) {
C.QTermWidgetInterface_setTextCodec(this.h, (*C.QTextCodec)(codec.UnsafePointer()))
}
func (this *QTermWidgetInterface) SetColorScheme(name string) {
name_ms := C.struct_miqt_string{}
name_ms.data = C.CString(name)
name_ms.len = C.size_t(len(name))
defer C.free(unsafe.Pointer(name_ms.data))
C.QTermWidgetInterface_setColorScheme(this.h, name_ms)
}
func (this *QTermWidgetInterface) GetAvailableColorSchemes() []string {
var _ma C.struct_miqt_array = C.QTermWidgetInterface_getAvailableColorSchemes(this.h)
_ret := make([]string, int(_ma.len))
_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
for i := 0; i < int(_ma.len); i++ {
var _lv_ms C.struct_miqt_string = _outCast[i]
_lv_ret := C.GoStringN(_lv_ms.data, C.int(int64(_lv_ms.len)))
C.free(unsafe.Pointer(_lv_ms.data))
_ret[i] = _lv_ret
}
return _ret
}
func (this *QTermWidgetInterface) SetHistorySize(lines int) {
C.QTermWidgetInterface_setHistorySize(this.h, (C.int)(lines))
}
func (this *QTermWidgetInterface) HistorySize() int {
return (int)(C.QTermWidgetInterface_historySize(this.h))
}
func (this *QTermWidgetInterface) SetScrollBarPosition(scrollBarPosition QTermWidgetInterface__ScrollBarPosition) {
C.QTermWidgetInterface_setScrollBarPosition(this.h, (C.int)(scrollBarPosition))
}
func (this *QTermWidgetInterface) ScrollToEnd() {
C.QTermWidgetInterface_scrollToEnd(this.h)
}
func (this *QTermWidgetInterface) SendText(text string) {
text_ms := C.struct_miqt_string{}
text_ms.data = C.CString(text)
text_ms.len = C.size_t(len(text))
defer C.free(unsafe.Pointer(text_ms.data))
C.QTermWidgetInterface_sendText(this.h, text_ms)
}
func (this *QTermWidgetInterface) SendKeyEvent(e *qt.QKeyEvent) {
C.QTermWidgetInterface_sendKeyEvent(this.h, (*C.QKeyEvent)(e.UnsafePointer()))
}
func (this *QTermWidgetInterface) SetFlowControlEnabled(enabled bool) {
C.QTermWidgetInterface_setFlowControlEnabled(this.h, (C.bool)(enabled))
}
func (this *QTermWidgetInterface) FlowControlEnabled() bool {
return (bool)(C.QTermWidgetInterface_flowControlEnabled(this.h))
}
func (this *QTermWidgetInterface) SetFlowControlWarningEnabled(enabled bool) {
C.QTermWidgetInterface_setFlowControlWarningEnabled(this.h, (C.bool)(enabled))
}
func (this *QTermWidgetInterface) KeyBindings() string {
var _ms C.struct_miqt_string = C.QTermWidgetInterface_keyBindings(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QTermWidgetInterface) SetMotionAfterPasting(motionAfterPasting int) {
C.QTermWidgetInterface_setMotionAfterPasting(this.h, (C.int)(motionAfterPasting))
}
func (this *QTermWidgetInterface) HistoryLinesCount() int {
return (int)(C.QTermWidgetInterface_historyLinesCount(this.h))
}
func (this *QTermWidgetInterface) ScreenColumnsCount() int {
return (int)(C.QTermWidgetInterface_screenColumnsCount(this.h))
}
func (this *QTermWidgetInterface) ScreenLinesCount() int {
return (int)(C.QTermWidgetInterface_screenLinesCount(this.h))
}
func (this *QTermWidgetInterface) SetSelectionStart(row int, column int) {
C.QTermWidgetInterface_setSelectionStart(this.h, (C.int)(row), (C.int)(column))
}
func (this *QTermWidgetInterface) SetSelectionEnd(row int, column int) {
C.QTermWidgetInterface_setSelectionEnd(this.h, (C.int)(row), (C.int)(column))
}
func (this *QTermWidgetInterface) GetSelectionStart(row *int, column *int) {
C.QTermWidgetInterface_getSelectionStart(this.h, (*C.int)(unsafe.Pointer(row)), (*C.int)(unsafe.Pointer(column)))
}
func (this *QTermWidgetInterface) GetSelectionEnd(row *int, column *int) {
C.QTermWidgetInterface_getSelectionEnd(this.h, (*C.int)(unsafe.Pointer(row)), (*C.int)(unsafe.Pointer(column)))
}
func (this *QTermWidgetInterface) SelectedText(preserveLineBreaks bool) string {
var _ms C.struct_miqt_string = C.QTermWidgetInterface_selectedText(this.h, (C.bool)(preserveLineBreaks))
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QTermWidgetInterface) SetMonitorActivity(monitorActivity bool) {
C.QTermWidgetInterface_setMonitorActivity(this.h, (C.bool)(monitorActivity))
}
func (this *QTermWidgetInterface) SetMonitorSilence(monitorSilence bool) {
C.QTermWidgetInterface_setMonitorSilence(this.h, (C.bool)(monitorSilence))
}
func (this *QTermWidgetInterface) SetSilenceTimeout(seconds int) {
C.QTermWidgetInterface_setSilenceTimeout(this.h, (C.int)(seconds))
}
func (this *QTermWidgetInterface) FilterActions(position *qt.QPoint) []*qt.QAction {
var _ma C.struct_miqt_array = C.QTermWidgetInterface_filterActions(this.h, (*C.QPoint)(position.UnsafePointer()))
_ret := make([]*qt.QAction, int(_ma.len))
_outCast := (*[0xffff]*C.QAction)(unsafe.Pointer(_ma.data)) // hey ya
for i := 0; i < int(_ma.len); i++ {
_ret[i] = qt.UnsafeNewQAction(unsafe.Pointer(_outCast[i]))
}
return _ret
}
func (this *QTermWidgetInterface) GetPtySlaveFd() int {
return (int)(C.QTermWidgetInterface_getPtySlaveFd(this.h))
}
func (this *QTermWidgetInterface) SetBlinkingCursor(blink bool) {
C.QTermWidgetInterface_setBlinkingCursor(this.h, (C.bool)(blink))
}
func (this *QTermWidgetInterface) SetBidiEnabled(enabled bool) {
C.QTermWidgetInterface_setBidiEnabled(this.h, (C.bool)(enabled))
}
func (this *QTermWidgetInterface) IsBidiEnabled() bool {
return (bool)(C.QTermWidgetInterface_isBidiEnabled(this.h))
}
func (this *QTermWidgetInterface) SetAutoClose(autoClose bool) {
C.QTermWidgetInterface_setAutoClose(this.h, (C.bool)(autoClose))
}
func (this *QTermWidgetInterface) Title() string {
var _ms C.struct_miqt_string = C.QTermWidgetInterface_title(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QTermWidgetInterface) Icon() string {
var _ms C.struct_miqt_string = C.QTermWidgetInterface_icon(this.h)
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
C.free(unsafe.Pointer(_ms.data))
return _ret
}
func (this *QTermWidgetInterface) IsTitleChanged() bool {
return (bool)(C.QTermWidgetInterface_isTitleChanged(this.h))
}
func (this *QTermWidgetInterface) BracketText(text string) {
text_ms := C.struct_miqt_string{}
text_ms.data = C.CString(text)
text_ms.len = C.size_t(len(text))
defer C.free(unsafe.Pointer(text_ms.data))
C.QTermWidgetInterface_bracketText(this.h, text_ms)
}
func (this *QTermWidgetInterface) DisableBracketedPasteMode(disable bool) {
C.QTermWidgetInterface_disableBracketedPasteMode(this.h, (C.bool)(disable))
}
func (this *QTermWidgetInterface) BracketedPasteModeIsDisabled() bool {
return (bool)(C.QTermWidgetInterface_bracketedPasteModeIsDisabled(this.h))
}
func (this *QTermWidgetInterface) SetMargin(margin int) {
C.QTermWidgetInterface_setMargin(this.h, (C.int)(margin))
}
func (this *QTermWidgetInterface) GetMargin() int {
return (int)(C.QTermWidgetInterface_getMargin(this.h))
}
func (this *QTermWidgetInterface) SetDrawLineChars(drawLineChars bool) {
C.QTermWidgetInterface_setDrawLineChars(this.h, (C.bool)(drawLineChars))
}
func (this *QTermWidgetInterface) SetBoldIntense(boldIntense bool) {
C.QTermWidgetInterface_setBoldIntense(this.h, (C.bool)(boldIntense))
}
func (this *QTermWidgetInterface) SetConfirmMultilinePaste(confirmMultilinePaste bool) {
C.QTermWidgetInterface_setConfirmMultilinePaste(this.h, (C.bool)(confirmMultilinePaste))
}
func (this *QTermWidgetInterface) SetTrimPastedTrailingNewlines(trimPastedTrailingNewlines bool) {
C.QTermWidgetInterface_setTrimPastedTrailingNewlines(this.h, (C.bool)(trimPastedTrailingNewlines))
}
func (this *QTermWidgetInterface) CreateWidget(startnow int) *QTermWidgetInterface {
return newQTermWidgetInterface(C.QTermWidgetInterface_createWidget(this.h, (C.int)(startnow)))
}
func (this *QTermWidgetInterface) OperatorAssign(param1 *QTermWidgetInterface) {
C.QTermWidgetInterface_operatorAssign(this.h, param1.cPointer())
}
// Delete this object from C++ memory.
func (this *QTermWidgetInterface) Delete() {
C.QTermWidgetInterface_delete(this.h)
}
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
// from C++ memory once it is unreachable from Go memory.
func (this *QTermWidgetInterface) GoGC() {
runtime.SetFinalizer(this, func(this *QTermWidgetInterface) {
this.Delete()
runtime.KeepAlive(this.h)
})
}

100
qt-restricted-extras/qtermwidget/gen_qtermwidget_interface.h Normal file
View File

@ -0,0 +1,100 @@
#pragma once
#ifndef MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_QTERMWIDGET_INTERFACE_H
#define MIQT_QT_RESTRICTED_EXTRAS_QTERMWIDGET_GEN_QTERMWIDGET_INTERFACE_H
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#include "../../libmiqt/libmiqt.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef __cplusplus
class QAction;
class QFont;
class QKeyEvent;
class QPoint;
class QTermWidgetInterface;
class QTextCodec;
#else
typedef struct QAction QAction;
typedef struct QFont QFont;
typedef struct QKeyEvent QKeyEvent;
typedef struct QPoint QPoint;
typedef struct QTermWidgetInterface QTermWidgetInterface;
typedef struct QTextCodec QTextCodec;
#endif
void QTermWidgetInterface_setTerminalSizeHint(QTermWidgetInterface* self, bool enabled);
bool QTermWidgetInterface_terminalSizeHint(QTermWidgetInterface* self);
void QTermWidgetInterface_startShellProgram(QTermWidgetInterface* self);
void QTermWidgetInterface_startTerminalTeletype(QTermWidgetInterface* self);
int QTermWidgetInterface_getShellPID(QTermWidgetInterface* self);
void QTermWidgetInterface_changeDir(QTermWidgetInterface* self, struct miqt_string dir);
void QTermWidgetInterface_setTerminalFont(QTermWidgetInterface* self, QFont* font);
QFont* QTermWidgetInterface_getTerminalFont(QTermWidgetInterface* self);
void QTermWidgetInterface_setTerminalOpacity(QTermWidgetInterface* self, double level);
void QTermWidgetInterface_setTerminalBackgroundImage(QTermWidgetInterface* self, struct miqt_string backgroundImage);
void QTermWidgetInterface_setTerminalBackgroundMode(QTermWidgetInterface* self, int mode);
void QTermWidgetInterface_setEnvironment(QTermWidgetInterface* self, struct miqt_array /* of struct miqt_string */ environment);
void QTermWidgetInterface_setShellProgram(QTermWidgetInterface* self, struct miqt_string program);
void QTermWidgetInterface_setWorkingDirectory(QTermWidgetInterface* self, struct miqt_string dir);
struct miqt_string QTermWidgetInterface_workingDirectory(QTermWidgetInterface* self);
void QTermWidgetInterface_setArgs(QTermWidgetInterface* self, struct miqt_array /* of struct miqt_string */ args);
void QTermWidgetInterface_setTextCodec(QTermWidgetInterface* self, QTextCodec* codec);
void QTermWidgetInterface_setColorScheme(QTermWidgetInterface* self, struct miqt_string name);
struct miqt_array /* of struct miqt_string */ QTermWidgetInterface_getAvailableColorSchemes(QTermWidgetInterface* self);
void QTermWidgetInterface_setHistorySize(QTermWidgetInterface* self, int lines);
int QTermWidgetInterface_historySize(const QTermWidgetInterface* self);
void QTermWidgetInterface_setScrollBarPosition(QTermWidgetInterface* self, int scrollBarPosition);
void QTermWidgetInterface_scrollToEnd(QTermWidgetInterface* self);
void QTermWidgetInterface_sendText(QTermWidgetInterface* self, struct miqt_string text);
void QTermWidgetInterface_sendKeyEvent(QTermWidgetInterface* self, QKeyEvent* e);
void QTermWidgetInterface_setFlowControlEnabled(QTermWidgetInterface* self, bool enabled);
bool QTermWidgetInterface_flowControlEnabled(QTermWidgetInterface* self);
void QTermWidgetInterface_setFlowControlWarningEnabled(QTermWidgetInterface* self, bool enabled);
struct miqt_string QTermWidgetInterface_keyBindings(QTermWidgetInterface* self);
void QTermWidgetInterface_setMotionAfterPasting(QTermWidgetInterface* self, int motionAfterPasting);
int QTermWidgetInterface_historyLinesCount(QTermWidgetInterface* self);
int QTermWidgetInterface_screenColumnsCount(QTermWidgetInterface* self);
int QTermWidgetInterface_screenLinesCount(QTermWidgetInterface* self);
void QTermWidgetInterface_setSelectionStart(QTermWidgetInterface* self, int row, int column);
void QTermWidgetInterface_setSelectionEnd(QTermWidgetInterface* self, int row, int column);
void QTermWidgetInterface_getSelectionStart(QTermWidgetInterface* self, int* row, int* column);
void QTermWidgetInterface_getSelectionEnd(QTermWidgetInterface* self, int* row, int* column);
struct miqt_string QTermWidgetInterface_selectedText(QTermWidgetInterface* self, bool preserveLineBreaks);
void QTermWidgetInterface_setMonitorActivity(QTermWidgetInterface* self, bool monitorActivity);
void QTermWidgetInterface_setMonitorSilence(QTermWidgetInterface* self, bool monitorSilence);
void QTermWidgetInterface_setSilenceTimeout(QTermWidgetInterface* self, int seconds);
struct miqt_array /* of QAction* */ QTermWidgetInterface_filterActions(QTermWidgetInterface* self, QPoint* position);
int QTermWidgetInterface_getPtySlaveFd(const QTermWidgetInterface* self);
void QTermWidgetInterface_setBlinkingCursor(QTermWidgetInterface* self, bool blink);
void QTermWidgetInterface_setBidiEnabled(QTermWidgetInterface* self, bool enabled);
bool QTermWidgetInterface_isBidiEnabled(QTermWidgetInterface* self);
void QTermWidgetInterface_setAutoClose(QTermWidgetInterface* self, bool autoClose);
struct miqt_string QTermWidgetInterface_title(const QTermWidgetInterface* self);
struct miqt_string QTermWidgetInterface_icon(const QTermWidgetInterface* self);
bool QTermWidgetInterface_isTitleChanged(const QTermWidgetInterface* self);
void QTermWidgetInterface_bracketText(QTermWidgetInterface* self, struct miqt_string text);
void QTermWidgetInterface_disableBracketedPasteMode(QTermWidgetInterface* self, bool disable);
bool QTermWidgetInterface_bracketedPasteModeIsDisabled(const QTermWidgetInterface* self);
void QTermWidgetInterface_setMargin(QTermWidgetInterface* self, int margin);
int QTermWidgetInterface_getMargin(const QTermWidgetInterface* self);
void QTermWidgetInterface_setDrawLineChars(QTermWidgetInterface* self, bool drawLineChars);
void QTermWidgetInterface_setBoldIntense(QTermWidgetInterface* self, bool boldIntense);
void QTermWidgetInterface_setConfirmMultilinePaste(QTermWidgetInterface* self, bool confirmMultilinePaste);
void QTermWidgetInterface_setTrimPastedTrailingNewlines(QTermWidgetInterface* self, bool trimPastedTrailingNewlines);
QTermWidgetInterface* QTermWidgetInterface_createWidget(const QTermWidgetInterface* self, int startnow);
void QTermWidgetInterface_operatorAssign(QTermWidgetInterface* self, QTermWidgetInterface* param1);
void QTermWidgetInterface_delete(QTermWidgetInterface* self);
#ifdef __cplusplus
} /* extern C */
#endif
#endif

2
qt/gen_qitemselectionmodel.go
View File

@ -1013,8 +1013,6 @@ func (this *QItemSelectionModel) GoGC() {
type QItemSelection struct {
h *C.QItemSelection
/* Also inherits unprojectable QList<QItemSelectionRange> */
}
func (this *QItemSelection) cPointer() *C.QItemSelection {

2
qt6/gen_qitemselectionmodel.go
View File

@ -974,8 +974,6 @@ func (this *QItemSelectionModel) GoGC() {
type QItemSelection struct {
h *C.QItemSelection
/* Also inherits unprojectable QList<QItemSelectionRange> */
}
func (this *QItemSelection) cPointer() *C.QItemSelection {