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

qtermwidget5: initial generation

Browse Source
This commit is contained in:
mappu 2025-04-12 16:00:34 +12:00
parent b973c5edc6
commit fc221118d3
15 changed files with 17977 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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