2025-01-19 16:39:11 +13:00
# include <QChildEvent>
2024-11-06 18:30:07 +13:00
# include <QColor>
2025-01-19 16:39:11 +13:00
# include <QEvent>
2024-11-19 19:29:06 +13:00
# include <QFont>
# include <QList>
2025-01-19 16:39:11 +13:00
# include <QMetaMethod>
2024-11-06 18:30:07 +13:00
# include <QMetaObject>
# include <QObject>
2024-11-19 19:29:06 +13:00
# include <QSettings>
2024-11-06 18:30:07 +13:00
# include <QString>
# include <QByteArray>
# include <cstring>
2025-01-19 16:39:11 +13:00
# include <QTimerEvent>
2024-11-06 18:30:07 +13:00
# include <qscilexertex.h>
# include "gen_qscilexertex.h"
2024-12-11 19:55:47 +13:00
2025-01-07 11:30:33 +01:00
# ifdef __cplusplus
extern " C " {
# endif
2025-02-01 13:45:16 +13:00
const char * miqt_exec_callback_QsciLexerTeX_language ( const QsciLexerTeX * , intptr_t ) ;
const char * miqt_exec_callback_QsciLexerTeX_lexer ( const QsciLexerTeX * , intptr_t ) ;
int miqt_exec_callback_QsciLexerTeX_lexerId ( const QsciLexerTeX * , intptr_t ) ;
const char * miqt_exec_callback_QsciLexerTeX_autoCompletionFillups ( const QsciLexerTeX * , intptr_t ) ;
struct miqt_array /* of struct miqt_string */ miqt_exec_callback_QsciLexerTeX_autoCompletionWordSeparators ( const QsciLexerTeX * , intptr_t ) ;
const char * miqt_exec_callback_QsciLexerTeX_blockEnd ( const QsciLexerTeX * , intptr_t , int * ) ;
int miqt_exec_callback_QsciLexerTeX_blockLookback ( const QsciLexerTeX * , intptr_t ) ;
const char * miqt_exec_callback_QsciLexerTeX_blockStart ( const QsciLexerTeX * , intptr_t , int * ) ;
const char * miqt_exec_callback_QsciLexerTeX_blockStartKeyword ( const QsciLexerTeX * , intptr_t , int * ) ;
int miqt_exec_callback_QsciLexerTeX_braceStyle ( const QsciLexerTeX * , intptr_t ) ;
bool miqt_exec_callback_QsciLexerTeX_caseSensitive ( const QsciLexerTeX * , intptr_t ) ;
QColor * miqt_exec_callback_QsciLexerTeX_color ( const QsciLexerTeX * , intptr_t , int ) ;
bool miqt_exec_callback_QsciLexerTeX_eolFill ( const QsciLexerTeX * , intptr_t , int ) ;
QFont * miqt_exec_callback_QsciLexerTeX_font ( const QsciLexerTeX * , intptr_t , int ) ;
int miqt_exec_callback_QsciLexerTeX_indentationGuideView ( const QsciLexerTeX * , intptr_t ) ;
const char * miqt_exec_callback_QsciLexerTeX_keywords ( const QsciLexerTeX * , intptr_t , int ) ;
int miqt_exec_callback_QsciLexerTeX_defaultStyle ( const QsciLexerTeX * , intptr_t ) ;
struct miqt_string miqt_exec_callback_QsciLexerTeX_description ( const QsciLexerTeX * , intptr_t , int ) ;
QColor * miqt_exec_callback_QsciLexerTeX_paper ( const QsciLexerTeX * , intptr_t , int ) ;
QColor * miqt_exec_callback_QsciLexerTeX_defaultColorWithStyle ( const QsciLexerTeX * , intptr_t , int ) ;
bool miqt_exec_callback_QsciLexerTeX_defaultEolFill ( const QsciLexerTeX * , intptr_t , int ) ;
QFont * miqt_exec_callback_QsciLexerTeX_defaultFontWithStyle ( const QsciLexerTeX * , intptr_t , int ) ;
QColor * miqt_exec_callback_QsciLexerTeX_defaultPaperWithStyle ( const QsciLexerTeX * , intptr_t , int ) ;
void miqt_exec_callback_QsciLexerTeX_setEditor ( QsciLexerTeX * , intptr_t , QsciScintilla * ) ;
void miqt_exec_callback_QsciLexerTeX_refreshProperties ( QsciLexerTeX * , intptr_t ) ;
int miqt_exec_callback_QsciLexerTeX_styleBitsNeeded ( const QsciLexerTeX * , intptr_t ) ;
const char * miqt_exec_callback_QsciLexerTeX_wordCharacters ( const QsciLexerTeX * , intptr_t ) ;
void miqt_exec_callback_QsciLexerTeX_setAutoIndentStyle ( QsciLexerTeX * , intptr_t , int ) ;
void miqt_exec_callback_QsciLexerTeX_setColor ( QsciLexerTeX * , intptr_t , QColor * , int ) ;
void miqt_exec_callback_QsciLexerTeX_setEolFill ( QsciLexerTeX * , intptr_t , bool , int ) ;
void miqt_exec_callback_QsciLexerTeX_setFont ( QsciLexerTeX * , intptr_t , QFont * , int ) ;
void miqt_exec_callback_QsciLexerTeX_setPaper ( QsciLexerTeX * , intptr_t , QColor * , int ) ;
bool miqt_exec_callback_QsciLexerTeX_readProperties ( QsciLexerTeX * , intptr_t , QSettings * , struct miqt_string ) ;
bool miqt_exec_callback_QsciLexerTeX_writeProperties ( const QsciLexerTeX * , intptr_t , QSettings * , struct miqt_string ) ;
bool miqt_exec_callback_QsciLexerTeX_event ( QsciLexerTeX * , intptr_t , QEvent * ) ;
bool miqt_exec_callback_QsciLexerTeX_eventFilter ( QsciLexerTeX * , intptr_t , QObject * , QEvent * ) ;
void miqt_exec_callback_QsciLexerTeX_timerEvent ( QsciLexerTeX * , intptr_t , QTimerEvent * ) ;
void miqt_exec_callback_QsciLexerTeX_childEvent ( QsciLexerTeX * , intptr_t , QChildEvent * ) ;
void miqt_exec_callback_QsciLexerTeX_customEvent ( QsciLexerTeX * , intptr_t , QEvent * ) ;
void miqt_exec_callback_QsciLexerTeX_connectNotify ( QsciLexerTeX * , intptr_t , QMetaMethod * ) ;
void miqt_exec_callback_QsciLexerTeX_disconnectNotify ( QsciLexerTeX * , intptr_t , QMetaMethod * ) ;
2025-01-07 11:30:33 +01:00
# ifdef __cplusplus
} /* extern C */
2024-12-11 19:55:47 +13:00
# endif
2024-11-06 18:30:07 +13:00
2025-01-18 17:42:41 +13:00
class MiqtVirtualQsciLexerTeX final : public QsciLexerTeX {
2024-11-19 19:29:06 +13:00
public :
MiqtVirtualQsciLexerTeX ( ) : QsciLexerTeX ( ) { } ;
MiqtVirtualQsciLexerTeX ( QObject * parent ) : QsciLexerTeX ( parent ) { } ;
2025-01-18 17:42:41 +13:00
virtual ~ MiqtVirtualQsciLexerTeX ( ) override = default ;
2024-11-19 19:29:06 +13:00
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__language = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * language ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__language = = 0 ) {
2024-11-19 19:29:06 +13:00
return nullptr ; // Pure virtual, there is no base we can call
}
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_language ( this , handle__language ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__lexer = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * lexer ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__lexer = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : lexer ( ) ;
}
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_lexer ( this , handle__lexer ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
const char * virtualbase_lexer ( ) const {
2024-11-19 19:29:06 +13:00
return ( const char * ) QsciLexerTeX : : lexer ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__lexerId = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual int lexerId ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__lexerId = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : lexerId ( ) ;
}
2025-02-01 13:45:16 +13:00
int callback_return_value = miqt_exec_callback_QsciLexerTeX_lexerId ( this , handle__lexerId ) ;
2024-11-19 19:29:06 +13:00
return static_cast < int > ( callback_return_value ) ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
int virtualbase_lexerId ( ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : lexerId ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__autoCompletionFillups = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * autoCompletionFillups ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__autoCompletionFillups = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : autoCompletionFillups ( ) ;
}
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_autoCompletionFillups ( this , handle__autoCompletionFillups ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
const char * virtualbase_autoCompletionFillups ( ) const {
2024-11-19 19:29:06 +13:00
return ( const char * ) QsciLexerTeX : : autoCompletionFillups ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__autoCompletionWordSeparators = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QStringList autoCompletionWordSeparators ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__autoCompletionWordSeparators = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : autoCompletionWordSeparators ( ) ;
}
2025-02-01 13:45:16 +13:00
struct miqt_array /* of struct miqt_string */ callback_return_value = miqt_exec_callback_QsciLexerTeX_autoCompletionWordSeparators ( this , handle__autoCompletionWordSeparators ) ;
2024-11-19 19:29:06 +13:00
QStringList callback_return_value_QList ;
callback_return_value_QList . reserve ( callback_return_value . len ) ;
struct miqt_string * callback_return_value_arr = static_cast < struct miqt_string * > ( callback_return_value . data ) ;
for ( size_t i = 0 ; i < callback_return_value . len ; + + i ) {
QString callback_return_value_arr_i_QString = QString : : fromUtf8 ( callback_return_value_arr [ i ] . data , callback_return_value_arr [ i ] . len ) ;
callback_return_value_QList . push_back ( callback_return_value_arr_i_QString ) ;
}
return callback_return_value_QList ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
struct miqt_array /* of struct miqt_string */ virtualbase_autoCompletionWordSeparators ( ) const {
2024-11-19 19:29:06 +13:00
QStringList _ret = QsciLexerTeX : : autoCompletionWordSeparators ( ) ;
// 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 ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__blockEnd = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * blockEnd ( int * style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__blockEnd = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : blockEnd ( style ) ;
}
int * sigval1 = style ;
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_blockEnd ( this , handle__blockEnd , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
const char * virtualbase_blockEnd ( int * style ) const {
2024-11-19 19:29:06 +13:00
return ( const char * ) QsciLexerTeX : : blockEnd ( static_cast < int * > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__blockLookback = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual int blockLookback ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__blockLookback = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : blockLookback ( ) ;
}
2025-02-01 13:45:16 +13:00
int callback_return_value = miqt_exec_callback_QsciLexerTeX_blockLookback ( this , handle__blockLookback ) ;
2024-11-19 19:29:06 +13:00
return static_cast < int > ( callback_return_value ) ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
int virtualbase_blockLookback ( ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : blockLookback ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__blockStart = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * blockStart ( int * style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__blockStart = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : blockStart ( style ) ;
}
int * sigval1 = style ;
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_blockStart ( this , handle__blockStart , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
const char * virtualbase_blockStart ( int * style ) const {
2024-11-19 19:29:06 +13:00
return ( const char * ) QsciLexerTeX : : blockStart ( static_cast < int * > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__blockStartKeyword = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * blockStartKeyword ( int * style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__blockStartKeyword = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : blockStartKeyword ( style ) ;
}
int * sigval1 = style ;
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_blockStartKeyword ( this , handle__blockStartKeyword , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
const char * virtualbase_blockStartKeyword ( int * style ) const {
2024-11-19 19:29:06 +13:00
return ( const char * ) QsciLexerTeX : : blockStartKeyword ( static_cast < int * > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__braceStyle = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual int braceStyle ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__braceStyle = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : braceStyle ( ) ;
}
2025-02-01 13:45:16 +13:00
int callback_return_value = miqt_exec_callback_QsciLexerTeX_braceStyle ( this , handle__braceStyle ) ;
2024-11-19 19:29:06 +13:00
return static_cast < int > ( callback_return_value ) ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
int virtualbase_braceStyle ( ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : braceStyle ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__caseSensitive = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual bool caseSensitive ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__caseSensitive = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : caseSensitive ( ) ;
}
2025-02-01 13:45:16 +13:00
bool callback_return_value = miqt_exec_callback_QsciLexerTeX_caseSensitive ( this , handle__caseSensitive ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
bool virtualbase_caseSensitive ( ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : caseSensitive ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__color = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QColor color ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__color = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : color ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
QColor * callback_return_value = miqt_exec_callback_QsciLexerTeX_color ( this , handle__color , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return * callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
QColor * virtualbase_color ( int style ) const {
2024-11-19 19:29:06 +13:00
return new QColor ( QsciLexerTeX : : color ( static_cast < int > ( style ) ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__eolFill = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual bool eolFill ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__eolFill = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : eolFill ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
bool callback_return_value = miqt_exec_callback_QsciLexerTeX_eolFill ( this , handle__eolFill , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
bool virtualbase_eolFill ( int style ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : eolFill ( static_cast < int > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__font = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QFont font ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__font = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : font ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
QFont * callback_return_value = miqt_exec_callback_QsciLexerTeX_font ( this , handle__font , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return * callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
QFont * virtualbase_font ( int style ) const {
2024-11-19 19:29:06 +13:00
return new QFont ( QsciLexerTeX : : font ( static_cast < int > ( style ) ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__indentationGuideView = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual int indentationGuideView ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__indentationGuideView = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : indentationGuideView ( ) ;
}
2025-02-01 13:45:16 +13:00
int callback_return_value = miqt_exec_callback_QsciLexerTeX_indentationGuideView ( this , handle__indentationGuideView ) ;
2024-11-19 19:29:06 +13:00
return static_cast < int > ( callback_return_value ) ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
int virtualbase_indentationGuideView ( ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : indentationGuideView ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__keywords = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * keywords ( int set ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__keywords = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : keywords ( set ) ;
}
int sigval1 = set ;
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_keywords ( this , handle__keywords , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
const char * virtualbase_keywords ( int set ) const {
2024-11-19 19:29:06 +13:00
return ( const char * ) QsciLexerTeX : : keywords ( static_cast < int > ( set ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__defaultStyle = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual int defaultStyle ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__defaultStyle = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : defaultStyle ( ) ;
}
2025-02-01 13:45:16 +13:00
int callback_return_value = miqt_exec_callback_QsciLexerTeX_defaultStyle ( this , handle__defaultStyle ) ;
2024-11-19 19:29:06 +13:00
return static_cast < int > ( callback_return_value ) ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
int virtualbase_defaultStyle ( ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : defaultStyle ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__description = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QString description ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__description = = 0 ) {
2024-11-19 19:29:06 +13:00
return QString ( ) ; // Pure virtual, there is no base we can call
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
struct miqt_string callback_return_value = miqt_exec_callback_QsciLexerTeX_description ( this , handle__description , sigval1 ) ;
2024-11-19 19:29:06 +13:00
QString callback_return_value_QString = QString : : fromUtf8 ( callback_return_value . data , callback_return_value . len ) ;
return callback_return_value_QString ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__paper = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QColor paper ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__paper = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : paper ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
QColor * callback_return_value = miqt_exec_callback_QsciLexerTeX_paper ( this , handle__paper , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return * callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
QColor * virtualbase_paper ( int style ) const {
2024-11-19 19:29:06 +13:00
return new QColor ( QsciLexerTeX : : paper ( static_cast < int > ( style ) ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__defaultColorWithStyle = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QColor defaultColor ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__defaultColorWithStyle = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : defaultColor ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
QColor * callback_return_value = miqt_exec_callback_QsciLexerTeX_defaultColorWithStyle ( this , handle__defaultColorWithStyle , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return * callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
QColor * virtualbase_defaultColorWithStyle ( int style ) const {
2024-11-19 19:29:06 +13:00
return new QColor ( QsciLexerTeX : : defaultColor ( static_cast < int > ( style ) ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__defaultEolFill = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual bool defaultEolFill ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__defaultEolFill = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : defaultEolFill ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
bool callback_return_value = miqt_exec_callback_QsciLexerTeX_defaultEolFill ( this , handle__defaultEolFill , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
bool virtualbase_defaultEolFill ( int style ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : defaultEolFill ( static_cast < int > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__defaultFontWithStyle = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QFont defaultFont ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__defaultFontWithStyle = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : defaultFont ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
QFont * callback_return_value = miqt_exec_callback_QsciLexerTeX_defaultFontWithStyle ( this , handle__defaultFontWithStyle , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return * callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
QFont * virtualbase_defaultFontWithStyle ( int style ) const {
2024-11-19 19:29:06 +13:00
return new QFont ( QsciLexerTeX : : defaultFont ( static_cast < int > ( style ) ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__defaultPaperWithStyle = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual QColor defaultPaper ( int style ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__defaultPaperWithStyle = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : defaultPaper ( style ) ;
}
int sigval1 = style ;
2025-02-01 13:45:16 +13:00
QColor * callback_return_value = miqt_exec_callback_QsciLexerTeX_defaultPaperWithStyle ( this , handle__defaultPaperWithStyle , sigval1 ) ;
2024-11-19 19:29:06 +13:00
return * callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
QColor * virtualbase_defaultPaperWithStyle ( int style ) const {
2024-11-19 19:29:06 +13:00
return new QColor ( QsciLexerTeX : : defaultPaper ( static_cast < int > ( style ) ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__setEditor = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual void setEditor ( QsciScintilla * editor ) override {
2025-02-01 13:45:16 +13:00
if ( handle__setEditor = = 0 ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setEditor ( editor ) ;
return ;
}
QsciScintilla * sigval1 = editor ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_setEditor ( this , handle__setEditor , sigval1 ) ;
2024-11-19 19:29:06 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_setEditor ( QsciScintilla * editor ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setEditor ( editor ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__refreshProperties = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual void refreshProperties ( ) override {
2025-02-01 13:45:16 +13:00
if ( handle__refreshProperties = = 0 ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : refreshProperties ( ) ;
return ;
}
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_refreshProperties ( this , handle__refreshProperties ) ;
2024-11-19 19:29:06 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_refreshProperties ( ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : refreshProperties ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__styleBitsNeeded = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual int styleBitsNeeded ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__styleBitsNeeded = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : styleBitsNeeded ( ) ;
}
2025-02-01 13:45:16 +13:00
int callback_return_value = miqt_exec_callback_QsciLexerTeX_styleBitsNeeded ( this , handle__styleBitsNeeded ) ;
2024-11-19 19:29:06 +13:00
return static_cast < int > ( callback_return_value ) ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
int virtualbase_styleBitsNeeded ( ) const {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : styleBitsNeeded ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__wordCharacters = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual const char * wordCharacters ( ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__wordCharacters = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : wordCharacters ( ) ;
}
2025-02-01 13:45:16 +13:00
const char * callback_return_value = miqt_exec_callback_QsciLexerTeX_wordCharacters ( this , handle__wordCharacters ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
const char * virtualbase_wordCharacters ( ) const {
2024-11-19 19:29:06 +13:00
return ( const char * ) QsciLexerTeX : : wordCharacters ( ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__setAutoIndentStyle = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual void setAutoIndentStyle ( int autoindentstyle ) override {
2025-02-01 13:45:16 +13:00
if ( handle__setAutoIndentStyle = = 0 ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setAutoIndentStyle ( autoindentstyle ) ;
return ;
}
int sigval1 = autoindentstyle ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_setAutoIndentStyle ( this , handle__setAutoIndentStyle , sigval1 ) ;
2024-11-19 19:29:06 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_setAutoIndentStyle ( int autoindentstyle ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setAutoIndentStyle ( static_cast < int > ( autoindentstyle ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__setColor = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual void setColor ( const QColor & c , int style ) override {
2025-02-01 13:45:16 +13:00
if ( handle__setColor = = 0 ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setColor ( c , style ) ;
return ;
}
const QColor & c_ret = c ;
// Cast returned reference into pointer
QColor * sigval1 = const_cast < QColor * > ( & c_ret ) ;
int sigval2 = style ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_setColor ( this , handle__setColor , sigval1 , sigval2 ) ;
2024-11-19 19:29:06 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_setColor ( QColor * c , int style ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setColor ( * c , static_cast < int > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__setEolFill = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual void setEolFill ( bool eoffill , int style ) override {
2025-02-01 13:45:16 +13:00
if ( handle__setEolFill = = 0 ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setEolFill ( eoffill , style ) ;
return ;
}
bool sigval1 = eoffill ;
int sigval2 = style ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_setEolFill ( this , handle__setEolFill , sigval1 , sigval2 ) ;
2024-11-19 19:29:06 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_setEolFill ( bool eoffill , int style ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setEolFill ( eoffill , static_cast < int > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__setFont = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual void setFont ( const QFont & f , int style ) override {
2025-02-01 13:45:16 +13:00
if ( handle__setFont = = 0 ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setFont ( f , style ) ;
return ;
}
const QFont & f_ret = f ;
// Cast returned reference into pointer
QFont * sigval1 = const_cast < QFont * > ( & f_ret ) ;
int sigval2 = style ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_setFont ( this , handle__setFont , sigval1 , sigval2 ) ;
2024-11-19 19:29:06 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_setFont ( QFont * f , int style ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setFont ( * f , static_cast < int > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__setPaper = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual void setPaper ( const QColor & c , int style ) override {
2025-02-01 13:45:16 +13:00
if ( handle__setPaper = = 0 ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setPaper ( c , style ) ;
return ;
}
const QColor & c_ret = c ;
// Cast returned reference into pointer
QColor * sigval1 = const_cast < QColor * > ( & c_ret ) ;
int sigval2 = style ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_setPaper ( this , handle__setPaper , sigval1 , sigval2 ) ;
2024-11-19 19:29:06 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_setPaper ( QColor * c , int style ) {
2024-11-19 19:29:06 +13:00
QsciLexerTeX : : setPaper ( * c , static_cast < int > ( style ) ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__readProperties = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual bool readProperties ( QSettings & qs , const QString & prefix ) override {
2025-02-01 13:45:16 +13:00
if ( handle__readProperties = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : readProperties ( qs , prefix ) ;
}
QSettings & qs_ret = qs ;
// Cast returned reference into pointer
QSettings * sigval1 = & qs_ret ;
const QString prefix_ret = prefix ;
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray prefix_b = prefix_ret . toUtf8 ( ) ;
struct miqt_string prefix_ms ;
prefix_ms . len = prefix_b . length ( ) ;
prefix_ms . data = static_cast < char * > ( malloc ( prefix_ms . len ) ) ;
memcpy ( prefix_ms . data , prefix_b . data ( ) , prefix_ms . len ) ;
struct miqt_string sigval2 = prefix_ms ;
2025-02-01 13:45:16 +13:00
bool callback_return_value = miqt_exec_callback_QsciLexerTeX_readProperties ( this , handle__readProperties , sigval1 , sigval2 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
bool virtualbase_readProperties ( QSettings * qs , struct miqt_string prefix ) {
2024-11-19 19:29:06 +13:00
QString prefix_QString = QString : : fromUtf8 ( prefix . data , prefix . len ) ;
return QsciLexerTeX : : readProperties ( * qs , prefix_QString ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__writeProperties = 0 ;
2024-11-19 19:29:06 +13:00
// Subclass to allow providing a Go implementation
virtual bool writeProperties ( QSettings & qs , const QString & prefix ) const override {
2025-02-01 13:45:16 +13:00
if ( handle__writeProperties = = 0 ) {
2024-11-19 19:29:06 +13:00
return QsciLexerTeX : : writeProperties ( qs , prefix ) ;
}
QSettings & qs_ret = qs ;
// Cast returned reference into pointer
QSettings * sigval1 = & qs_ret ;
const QString prefix_ret = prefix ;
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray prefix_b = prefix_ret . toUtf8 ( ) ;
struct miqt_string prefix_ms ;
prefix_ms . len = prefix_b . length ( ) ;
prefix_ms . data = static_cast < char * > ( malloc ( prefix_ms . len ) ) ;
memcpy ( prefix_ms . data , prefix_b . data ( ) , prefix_ms . len ) ;
struct miqt_string sigval2 = prefix_ms ;
2025-02-01 13:45:16 +13:00
bool callback_return_value = miqt_exec_callback_QsciLexerTeX_writeProperties ( this , handle__writeProperties , sigval1 , sigval2 ) ;
2024-11-19 19:29:06 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
bool virtualbase_writeProperties ( QSettings * qs , struct miqt_string prefix ) const {
2024-11-19 19:29:06 +13:00
QString prefix_QString = QString : : fromUtf8 ( prefix . data , prefix . len ) ;
return QsciLexerTeX : : writeProperties ( * qs , prefix_QString ) ;
}
2025-01-19 16:39:11 +13:00
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__event = 0 ;
2025-01-19 16:39:11 +13:00
// Subclass to allow providing a Go implementation
virtual bool event ( QEvent * event ) override {
2025-02-01 13:45:16 +13:00
if ( handle__event = = 0 ) {
2025-01-19 16:39:11 +13:00
return QsciLexerTeX : : event ( event ) ;
}
QEvent * sigval1 = event ;
2025-02-01 13:45:16 +13:00
bool callback_return_value = miqt_exec_callback_QsciLexerTeX_event ( this , handle__event , sigval1 ) ;
2025-01-19 16:39:11 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
bool virtualbase_event ( QEvent * event ) {
2025-01-19 16:39:11 +13:00
return QsciLexerTeX : : event ( event ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__eventFilter = 0 ;
2025-01-19 16:39:11 +13:00
// Subclass to allow providing a Go implementation
virtual bool eventFilter ( QObject * watched , QEvent * event ) override {
2025-02-01 13:45:16 +13:00
if ( handle__eventFilter = = 0 ) {
2025-01-19 16:39:11 +13:00
return QsciLexerTeX : : eventFilter ( watched , event ) ;
}
QObject * sigval1 = watched ;
QEvent * sigval2 = event ;
2025-02-01 13:45:16 +13:00
bool callback_return_value = miqt_exec_callback_QsciLexerTeX_eventFilter ( this , handle__eventFilter , sigval1 , sigval2 ) ;
2025-01-19 16:39:11 +13:00
return callback_return_value ;
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
bool virtualbase_eventFilter ( QObject * watched , QEvent * event ) {
2025-01-19 16:39:11 +13:00
return QsciLexerTeX : : eventFilter ( watched , event ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__timerEvent = 0 ;
2025-01-19 16:39:11 +13:00
// Subclass to allow providing a Go implementation
virtual void timerEvent ( QTimerEvent * event ) override {
2025-02-01 13:45:16 +13:00
if ( handle__timerEvent = = 0 ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : timerEvent ( event ) ;
return ;
}
QTimerEvent * sigval1 = event ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_timerEvent ( this , handle__timerEvent , sigval1 ) ;
2025-01-19 16:39:11 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_timerEvent ( QTimerEvent * event ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : timerEvent ( event ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__childEvent = 0 ;
2025-01-19 16:39:11 +13:00
// Subclass to allow providing a Go implementation
virtual void childEvent ( QChildEvent * event ) override {
2025-02-01 13:45:16 +13:00
if ( handle__childEvent = = 0 ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : childEvent ( event ) ;
return ;
}
QChildEvent * sigval1 = event ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_childEvent ( this , handle__childEvent , sigval1 ) ;
2025-01-19 16:39:11 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_childEvent ( QChildEvent * event ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : childEvent ( event ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__customEvent = 0 ;
2025-01-19 16:39:11 +13:00
// Subclass to allow providing a Go implementation
virtual void customEvent ( QEvent * event ) override {
2025-02-01 13:45:16 +13:00
if ( handle__customEvent = = 0 ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : customEvent ( event ) ;
return ;
}
QEvent * sigval1 = event ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_customEvent ( this , handle__customEvent , sigval1 ) ;
2025-01-19 16:39:11 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_customEvent ( QEvent * event ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : customEvent ( event ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__connectNotify = 0 ;
2025-01-19 16:39:11 +13:00
// Subclass to allow providing a Go implementation
virtual void connectNotify ( const QMetaMethod & signal ) override {
2025-02-01 13:45:16 +13:00
if ( handle__connectNotify = = 0 ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : connectNotify ( signal ) ;
return ;
}
const QMetaMethod & signal_ret = signal ;
// Cast returned reference into pointer
QMetaMethod * sigval1 = const_cast < QMetaMethod * > ( & signal_ret ) ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_connectNotify ( this , handle__connectNotify , sigval1 ) ;
2025-01-19 16:39:11 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_connectNotify ( QMetaMethod * signal ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : connectNotify ( * signal ) ;
}
// cgo.Handle value for overwritten implementation
2025-02-01 13:45:16 +13:00
intptr_t handle__disconnectNotify = 0 ;
2025-01-19 16:39:11 +13:00
// Subclass to allow providing a Go implementation
virtual void disconnectNotify ( const QMetaMethod & signal ) override {
2025-02-01 13:45:16 +13:00
if ( handle__disconnectNotify = = 0 ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : disconnectNotify ( signal ) ;
return ;
}
const QMetaMethod & signal_ret = signal ;
// Cast returned reference into pointer
QMetaMethod * sigval1 = const_cast < QMetaMethod * > ( & signal_ret ) ;
2025-02-01 13:45:16 +13:00
miqt_exec_callback_QsciLexerTeX_disconnectNotify ( this , handle__disconnectNotify , sigval1 ) ;
2025-01-19 16:39:11 +13:00
}
// Wrapper to allow calling protected method
2025-02-01 13:45:16 +13:00
void virtualbase_disconnectNotify ( QMetaMethod * signal ) {
2025-01-19 16:39:11 +13:00
QsciLexerTeX : : disconnectNotify ( * signal ) ;
}
2024-11-19 19:29:06 +13:00
} ;
2024-12-07 17:15:57 +13:00
QsciLexerTeX * QsciLexerTeX_new ( ) {
return new MiqtVirtualQsciLexerTeX ( ) ;
2024-11-06 18:30:07 +13:00
}
2024-12-07 17:15:57 +13:00
QsciLexerTeX * QsciLexerTeX_new2 ( QObject * parent ) {
return new MiqtVirtualQsciLexerTeX ( parent ) ;
}
void QsciLexerTeX_virtbase ( QsciLexerTeX * src , QsciLexer * * outptr_QsciLexer ) {
* outptr_QsciLexer = static_cast < QsciLexer * > ( src ) ;
2024-11-06 18:30:07 +13:00
}
2025-02-01 13:45:16 +13:00
QMetaObject * QsciLexerTeX_metaObject ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return ( QMetaObject * ) self - > metaObject ( ) ;
}
2025-02-01 13:45:16 +13:00
void * QsciLexerTeX_metacast ( QsciLexerTeX * self , const char * param1 ) {
2024-11-06 18:30:07 +13:00
return self - > qt_metacast ( param1 ) ;
}
2025-02-01 13:45:16 +13:00
struct miqt_string QsciLexerTeX_tr ( const char * s ) {
2024-11-06 18:30:07 +13:00
QString _ret = QsciLexerTeX : : tr ( s ) ;
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret . toUtf8 ( ) ;
struct miqt_string _ms ;
_ms . len = _b . length ( ) ;
_ms . data = static_cast < char * > ( malloc ( _ms . len ) ) ;
memcpy ( _ms . data , _b . data ( ) , _ms . len ) ;
return _ms ;
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_language ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return ( const char * ) self - > language ( ) ;
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_lexer ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return ( const char * ) self - > lexer ( ) ;
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_wordCharacters ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return ( const char * ) self - > wordCharacters ( ) ;
}
2025-02-01 13:45:16 +13:00
QColor * QsciLexerTeX_defaultColor ( const QsciLexerTeX * self , int style ) {
2024-11-06 18:30:07 +13:00
return new QColor ( self - > defaultColor ( static_cast < int > ( style ) ) ) ;
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_keywords ( const QsciLexerTeX * self , int set ) {
2024-11-06 18:30:07 +13:00
return ( const char * ) self - > keywords ( static_cast < int > ( set ) ) ;
}
2025-02-01 13:45:16 +13:00
struct miqt_string QsciLexerTeX_description ( const QsciLexerTeX * self , int style ) {
2024-11-06 18:30:07 +13:00
QString _ret = self - > description ( static_cast < int > ( style ) ) ;
// 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 ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_refreshProperties ( QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
self - > refreshProperties ( ) ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_setFoldComments ( QsciLexerTeX * self , bool fold ) {
2024-11-06 18:30:07 +13:00
self - > setFoldComments ( fold ) ;
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_foldComments ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return self - > foldComments ( ) ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_setFoldCompact ( QsciLexerTeX * self , bool fold ) {
2024-11-06 18:30:07 +13:00
self - > setFoldCompact ( fold ) ;
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_foldCompact ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return self - > foldCompact ( ) ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_setProcessComments ( QsciLexerTeX * self , bool enable ) {
2024-11-06 18:30:07 +13:00
self - > setProcessComments ( enable ) ;
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_processComments ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return self - > processComments ( ) ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_setProcessIf ( QsciLexerTeX * self , bool enable ) {
2024-11-06 18:30:07 +13:00
self - > setProcessIf ( enable ) ;
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_processIf ( const QsciLexerTeX * self ) {
2024-11-06 18:30:07 +13:00
return self - > processIf ( ) ;
}
2025-02-01 13:45:16 +13:00
struct miqt_string QsciLexerTeX_tr2 ( const char * s , const char * c ) {
2024-11-06 18:30:07 +13:00
QString _ret = QsciLexerTeX : : tr ( s , c ) ;
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret . toUtf8 ( ) ;
struct miqt_string _ms ;
_ms . len = _b . length ( ) ;
_ms . data = static_cast < char * > ( malloc ( _ms . len ) ) ;
memcpy ( _ms . data , _b . data ( ) , _ms . len ) ;
return _ms ;
}
2025-02-01 13:45:16 +13:00
struct miqt_string QsciLexerTeX_tr3 ( const char * s , const char * c , int n ) {
2024-11-06 18:30:07 +13:00
QString _ret = QsciLexerTeX : : tr ( s , c , static_cast < int > ( n ) ) ;
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
QByteArray _b = _ret . toUtf8 ( ) ;
struct miqt_string _ms ;
_ms . len = _b . length ( ) ;
_ms . data = static_cast < char * > ( malloc ( _ms . len ) ) ;
memcpy ( _ms . data , _b . data ( ) , _ms . len ) ;
return _ms ;
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_language ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__language = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_lexer ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__lexer = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_virtualbase_lexer ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_lexer ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_lexerId ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__lexerId = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
int QsciLexerTeX_virtualbase_lexerId ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_lexerId ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_autoCompletionFillups ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__autoCompletionFillups = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_virtualbase_autoCompletionFillups ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_autoCompletionFillups ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_autoCompletionWordSeparators ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__autoCompletionWordSeparators = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
struct miqt_array /* of struct miqt_string */ QsciLexerTeX_virtualbase_autoCompletionWordSeparators ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_autoCompletionWordSeparators ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_blockEnd ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__blockEnd = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_virtualbase_blockEnd ( const void * self , int * style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_blockEnd ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_blockLookback ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__blockLookback = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
int QsciLexerTeX_virtualbase_blockLookback ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_blockLookback ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_blockStart ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__blockStart = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_virtualbase_blockStart ( const void * self , int * style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_blockStart ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_blockStartKeyword ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__blockStartKeyword = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_virtualbase_blockStartKeyword ( const void * self , int * style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_blockStartKeyword ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_braceStyle ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__braceStyle = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
int QsciLexerTeX_virtualbase_braceStyle ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_braceStyle ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_caseSensitive ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__caseSensitive = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_virtualbase_caseSensitive ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_caseSensitive ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_color ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__color = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
QColor * QsciLexerTeX_virtualbase_color ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_color ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_eolFill ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__eolFill = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_virtualbase_eolFill ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_eolFill ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_font ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__font = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
QFont * QsciLexerTeX_virtualbase_font ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_font ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_indentationGuideView ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__indentationGuideView = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
int QsciLexerTeX_virtualbase_indentationGuideView ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_indentationGuideView ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_keywords ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__keywords = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_virtualbase_keywords ( const void * self , int set ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_keywords ( set ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_defaultStyle ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__defaultStyle = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
int QsciLexerTeX_virtualbase_defaultStyle ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_defaultStyle ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_description ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__description = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_paper ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__paper = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
QColor * QsciLexerTeX_virtualbase_paper ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_paper ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_defaultColorWithStyle ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__defaultColorWithStyle = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
QColor * QsciLexerTeX_virtualbase_defaultColorWithStyle ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_defaultColorWithStyle ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_defaultEolFill ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__defaultEolFill = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_virtualbase_defaultEolFill ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_defaultEolFill ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_defaultFontWithStyle ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__defaultFontWithStyle = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
QFont * QsciLexerTeX_virtualbase_defaultFontWithStyle ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_defaultFontWithStyle ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_defaultPaperWithStyle ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__defaultPaperWithStyle = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
QColor * QsciLexerTeX_virtualbase_defaultPaperWithStyle ( const void * self , int style ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_defaultPaperWithStyle ( style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_setEditor ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__setEditor = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_setEditor ( void * self , QsciScintilla * editor ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_setEditor ( editor ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_refreshProperties ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__refreshProperties = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_refreshProperties ( void * self ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_refreshProperties ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_styleBitsNeeded ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__styleBitsNeeded = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
int QsciLexerTeX_virtualbase_styleBitsNeeded ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_styleBitsNeeded ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_wordCharacters ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__wordCharacters = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
const char * QsciLexerTeX_virtualbase_wordCharacters ( const void * self ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_wordCharacters ( ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_setAutoIndentStyle ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__setAutoIndentStyle = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_setAutoIndentStyle ( void * self , int autoindentstyle ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_setAutoIndentStyle ( autoindentstyle ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_setColor ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__setColor = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_setColor ( void * self , QColor * c , int style ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_setColor ( c , style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_setEolFill ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__setEolFill = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_setEolFill ( void * self , bool eoffill , int style ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_setEolFill ( eoffill , style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_setFont ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__setFont = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_setFont ( void * self , QFont * f , int style ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_setFont ( f , style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_setPaper ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__setPaper = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_setPaper ( void * self , QColor * c , int style ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_setPaper ( c , style ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_readProperties ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__readProperties = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_virtualbase_readProperties ( void * self , QSettings * qs , struct miqt_string prefix ) {
return ( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_readProperties ( qs , prefix ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_writeProperties ( void * self , intptr_t slot ) {
2025-01-18 17:57:48 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__writeProperties = slot ;
2025-01-18 17:57:48 +13:00
return true ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_virtualbase_writeProperties ( const void * self , QSettings * qs , struct miqt_string prefix ) {
return ( ( const MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_writeProperties ( qs , prefix ) ;
2024-11-19 19:29:06 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_event ( void * self , intptr_t slot ) {
2025-01-19 16:39:11 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__event = slot ;
2025-01-19 16:39:11 +13:00
return true ;
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_virtualbase_event ( void * self , QEvent * event ) {
return ( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_event ( event ) ;
2025-01-19 16:39:11 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_eventFilter ( void * self , intptr_t slot ) {
2025-01-19 16:39:11 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__eventFilter = slot ;
2025-01-19 16:39:11 +13:00
return true ;
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_virtualbase_eventFilter ( void * self , QObject * watched , QEvent * event ) {
return ( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_eventFilter ( watched , event ) ;
2025-01-19 16:39:11 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_timerEvent ( void * self , intptr_t slot ) {
2025-01-19 16:39:11 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__timerEvent = slot ;
2025-01-19 16:39:11 +13:00
return true ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_timerEvent ( void * self , QTimerEvent * event ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_timerEvent ( event ) ;
2025-01-19 16:39:11 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_childEvent ( void * self , intptr_t slot ) {
2025-01-19 16:39:11 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__childEvent = slot ;
2025-01-19 16:39:11 +13:00
return true ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_childEvent ( void * self , QChildEvent * event ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_childEvent ( event ) ;
2025-01-19 16:39:11 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_customEvent ( void * self , intptr_t slot ) {
2025-01-19 16:39:11 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__customEvent = slot ;
2025-01-19 16:39:11 +13:00
return true ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_customEvent ( void * self , QEvent * event ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_customEvent ( event ) ;
2025-01-19 16:39:11 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_connectNotify ( void * self , intptr_t slot ) {
2025-01-19 16:39:11 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__connectNotify = slot ;
2025-01-19 16:39:11 +13:00
return true ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_connectNotify ( void * self , QMetaMethod * signal ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_connectNotify ( signal ) ;
2025-01-19 16:39:11 +13:00
}
2025-02-01 13:45:16 +13:00
bool QsciLexerTeX_override_virtual_disconnectNotify ( void * self , intptr_t slot ) {
2025-01-19 16:39:11 +13:00
MiqtVirtualQsciLexerTeX * self_cast = dynamic_cast < MiqtVirtualQsciLexerTeX * > ( ( QsciLexerTeX * ) ( self ) ) ;
if ( self_cast = = nullptr ) {
return false ;
}
2025-02-01 13:45:16 +13:00
self_cast - > handle__disconnectNotify = slot ;
2025-01-19 16:39:11 +13:00
return true ;
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_virtualbase_disconnectNotify ( void * self , QMetaMethod * signal ) {
( ( MiqtVirtualQsciLexerTeX * ) ( self ) ) - > virtualbase_disconnectNotify ( signal ) ;
2025-01-19 16:39:11 +13:00
}
2025-02-01 13:45:16 +13:00
void QsciLexerTeX_delete ( QsciLexerTeX * self ) {
2025-01-18 17:42:41 +13:00
delete self ;
2024-11-06 18:30:07 +13:00
}