mirror of
https://github.com/mappu/miqt.git
synced 2025-02-01 19:10:21 +00:00
1103 lines
33 KiB
C++
1103 lines
33 KiB
C++
#include <QByteArray>
|
|
#include <QChildEvent>
|
|
#include <QEvent>
|
|
#include <QIODevice>
|
|
#include <QImage>
|
|
#include <QImageIOHandler>
|
|
#include <QImageIOPlugin>
|
|
#include <QMetaMethod>
|
|
#include <QMetaObject>
|
|
#include <QObject>
|
|
#include <QRect>
|
|
#include <QString>
|
|
#include <QByteArray>
|
|
#include <cstring>
|
|
#include <QTimerEvent>
|
|
#include <QVariant>
|
|
#include <qimageiohandler.h>
|
|
#include "gen_qimageiohandler.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
struct miqt_string miqt_exec_callback_QImageIOHandler_name(const QImageIOHandler*, intptr_t);
|
|
bool miqt_exec_callback_QImageIOHandler_canRead(const QImageIOHandler*, intptr_t);
|
|
bool miqt_exec_callback_QImageIOHandler_read(QImageIOHandler*, intptr_t, QImage*);
|
|
bool miqt_exec_callback_QImageIOHandler_write(QImageIOHandler*, intptr_t, QImage*);
|
|
QVariant* miqt_exec_callback_QImageIOHandler_option(const QImageIOHandler*, intptr_t, int);
|
|
void miqt_exec_callback_QImageIOHandler_setOption(QImageIOHandler*, intptr_t, int, QVariant*);
|
|
bool miqt_exec_callback_QImageIOHandler_supportsOption(const QImageIOHandler*, intptr_t, int);
|
|
bool miqt_exec_callback_QImageIOHandler_jumpToNextImage(QImageIOHandler*, intptr_t);
|
|
bool miqt_exec_callback_QImageIOHandler_jumpToImage(QImageIOHandler*, intptr_t, int);
|
|
int miqt_exec_callback_QImageIOHandler_loopCount(const QImageIOHandler*, intptr_t);
|
|
int miqt_exec_callback_QImageIOHandler_imageCount(const QImageIOHandler*, intptr_t);
|
|
int miqt_exec_callback_QImageIOHandler_nextImageDelay(const QImageIOHandler*, intptr_t);
|
|
int miqt_exec_callback_QImageIOHandler_currentImageNumber(const QImageIOHandler*, intptr_t);
|
|
QRect* miqt_exec_callback_QImageIOHandler_currentImageRect(const QImageIOHandler*, intptr_t);
|
|
int miqt_exec_callback_QImageIOPlugin_capabilities(const QImageIOPlugin*, intptr_t, QIODevice*, struct miqt_string);
|
|
QImageIOHandler* miqt_exec_callback_QImageIOPlugin_create(const QImageIOPlugin*, intptr_t, QIODevice*, struct miqt_string);
|
|
bool miqt_exec_callback_QImageIOPlugin_event(QImageIOPlugin*, intptr_t, QEvent*);
|
|
bool miqt_exec_callback_QImageIOPlugin_eventFilter(QImageIOPlugin*, intptr_t, QObject*, QEvent*);
|
|
void miqt_exec_callback_QImageIOPlugin_timerEvent(QImageIOPlugin*, intptr_t, QTimerEvent*);
|
|
void miqt_exec_callback_QImageIOPlugin_childEvent(QImageIOPlugin*, intptr_t, QChildEvent*);
|
|
void miqt_exec_callback_QImageIOPlugin_customEvent(QImageIOPlugin*, intptr_t, QEvent*);
|
|
void miqt_exec_callback_QImageIOPlugin_connectNotify(QImageIOPlugin*, intptr_t, QMetaMethod*);
|
|
void miqt_exec_callback_QImageIOPlugin_disconnectNotify(QImageIOPlugin*, intptr_t, QMetaMethod*);
|
|
#ifdef __cplusplus
|
|
} /* extern C */
|
|
#endif
|
|
|
|
class MiqtVirtualQImageIOHandler final : public QImageIOHandler {
|
|
public:
|
|
|
|
MiqtVirtualQImageIOHandler(): QImageIOHandler() {};
|
|
|
|
virtual ~MiqtVirtualQImageIOHandler() override = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__name = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QByteArray name() const override {
|
|
if (handle__name == 0) {
|
|
return QImageIOHandler::name();
|
|
}
|
|
|
|
|
|
struct miqt_string callback_return_value = miqt_exec_callback_QImageIOHandler_name(this, handle__name);
|
|
QByteArray callback_return_value_QByteArray(callback_return_value.data, callback_return_value.len);
|
|
|
|
return callback_return_value_QByteArray;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
struct miqt_string virtualbase_name() const {
|
|
|
|
QByteArray _qb = QImageIOHandler::name();
|
|
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;
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__canRead = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool canRead() const override {
|
|
if (handle__canRead == 0) {
|
|
return false; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOHandler_canRead(this, handle__canRead);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__read = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool read(QImage* image) override {
|
|
if (handle__read == 0) {
|
|
return false; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
QImage* sigval1 = image;
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOHandler_read(this, handle__read, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__write = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool write(const QImage& image) override {
|
|
if (handle__write == 0) {
|
|
return QImageIOHandler::write(image);
|
|
}
|
|
|
|
const QImage& image_ret = image;
|
|
// Cast returned reference into pointer
|
|
QImage* sigval1 = const_cast<QImage*>(&image_ret);
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOHandler_write(this, handle__write, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
bool virtualbase_write(QImage* image) {
|
|
|
|
return QImageIOHandler::write(*image);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__option = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QVariant option(QImageIOHandler::ImageOption option) const override {
|
|
if (handle__option == 0) {
|
|
return QImageIOHandler::option(option);
|
|
}
|
|
|
|
QImageIOHandler::ImageOption option_ret = option;
|
|
int sigval1 = static_cast<int>(option_ret);
|
|
|
|
QVariant* callback_return_value = miqt_exec_callback_QImageIOHandler_option(this, handle__option, sigval1);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
QVariant* virtualbase_option(int option) const {
|
|
|
|
return new QVariant(QImageIOHandler::option(static_cast<QImageIOHandler::ImageOption>(option)));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__setOption = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void setOption(QImageIOHandler::ImageOption option, const QVariant& value) override {
|
|
if (handle__setOption == 0) {
|
|
QImageIOHandler::setOption(option, value);
|
|
return;
|
|
}
|
|
|
|
QImageIOHandler::ImageOption option_ret = option;
|
|
int sigval1 = static_cast<int>(option_ret);
|
|
const QVariant& value_ret = value;
|
|
// Cast returned reference into pointer
|
|
QVariant* sigval2 = const_cast<QVariant*>(&value_ret);
|
|
|
|
miqt_exec_callback_QImageIOHandler_setOption(this, handle__setOption, sigval1, sigval2);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_setOption(int option, QVariant* value) {
|
|
|
|
QImageIOHandler::setOption(static_cast<QImageIOHandler::ImageOption>(option), *value);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__supportsOption = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool supportsOption(QImageIOHandler::ImageOption option) const override {
|
|
if (handle__supportsOption == 0) {
|
|
return QImageIOHandler::supportsOption(option);
|
|
}
|
|
|
|
QImageIOHandler::ImageOption option_ret = option;
|
|
int sigval1 = static_cast<int>(option_ret);
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOHandler_supportsOption(this, handle__supportsOption, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
bool virtualbase_supportsOption(int option) const {
|
|
|
|
return QImageIOHandler::supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__jumpToNextImage = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool jumpToNextImage() override {
|
|
if (handle__jumpToNextImage == 0) {
|
|
return QImageIOHandler::jumpToNextImage();
|
|
}
|
|
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOHandler_jumpToNextImage(this, handle__jumpToNextImage);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
bool virtualbase_jumpToNextImage() {
|
|
|
|
return QImageIOHandler::jumpToNextImage();
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__jumpToImage = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool jumpToImage(int imageNumber) override {
|
|
if (handle__jumpToImage == 0) {
|
|
return QImageIOHandler::jumpToImage(imageNumber);
|
|
}
|
|
|
|
int sigval1 = imageNumber;
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOHandler_jumpToImage(this, handle__jumpToImage, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
bool virtualbase_jumpToImage(int imageNumber) {
|
|
|
|
return QImageIOHandler::jumpToImage(static_cast<int>(imageNumber));
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__loopCount = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int loopCount() const override {
|
|
if (handle__loopCount == 0) {
|
|
return QImageIOHandler::loopCount();
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_QImageIOHandler_loopCount(this, handle__loopCount);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
int virtualbase_loopCount() const {
|
|
|
|
return QImageIOHandler::loopCount();
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__imageCount = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int imageCount() const override {
|
|
if (handle__imageCount == 0) {
|
|
return QImageIOHandler::imageCount();
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_QImageIOHandler_imageCount(this, handle__imageCount);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
int virtualbase_imageCount() const {
|
|
|
|
return QImageIOHandler::imageCount();
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__nextImageDelay = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int nextImageDelay() const override {
|
|
if (handle__nextImageDelay == 0) {
|
|
return QImageIOHandler::nextImageDelay();
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_QImageIOHandler_nextImageDelay(this, handle__nextImageDelay);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
int virtualbase_nextImageDelay() const {
|
|
|
|
return QImageIOHandler::nextImageDelay();
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__currentImageNumber = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual int currentImageNumber() const override {
|
|
if (handle__currentImageNumber == 0) {
|
|
return QImageIOHandler::currentImageNumber();
|
|
}
|
|
|
|
|
|
int callback_return_value = miqt_exec_callback_QImageIOHandler_currentImageNumber(this, handle__currentImageNumber);
|
|
|
|
return static_cast<int>(callback_return_value);
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
int virtualbase_currentImageNumber() const {
|
|
|
|
return QImageIOHandler::currentImageNumber();
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__currentImageRect = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QRect currentImageRect() const override {
|
|
if (handle__currentImageRect == 0) {
|
|
return QImageIOHandler::currentImageRect();
|
|
}
|
|
|
|
|
|
QRect* callback_return_value = miqt_exec_callback_QImageIOHandler_currentImageRect(this, handle__currentImageRect);
|
|
|
|
return *callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
QRect* virtualbase_currentImageRect() const {
|
|
|
|
return new QRect(QImageIOHandler::currentImageRect());
|
|
|
|
}
|
|
|
|
};
|
|
|
|
QImageIOHandler* QImageIOHandler_new() {
|
|
return new MiqtVirtualQImageIOHandler();
|
|
}
|
|
|
|
void QImageIOHandler_setDevice(QImageIOHandler* self, QIODevice* device) {
|
|
self->setDevice(device);
|
|
}
|
|
|
|
QIODevice* QImageIOHandler_device(const QImageIOHandler* self) {
|
|
return self->device();
|
|
}
|
|
|
|
void QImageIOHandler_setFormat(QImageIOHandler* self, struct miqt_string format) {
|
|
QByteArray format_QByteArray(format.data, format.len);
|
|
self->setFormat(format_QByteArray);
|
|
}
|
|
|
|
void QImageIOHandler_setFormatWithFormat(const QImageIOHandler* self, struct miqt_string format) {
|
|
QByteArray format_QByteArray(format.data, format.len);
|
|
self->setFormat(format_QByteArray);
|
|
}
|
|
|
|
struct miqt_string QImageIOHandler_format(const QImageIOHandler* self) {
|
|
QByteArray _qb = self->format();
|
|
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 QImageIOHandler_name(const QImageIOHandler* self) {
|
|
QByteArray _qb = self->name();
|
|
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;
|
|
}
|
|
|
|
bool QImageIOHandler_canRead(const QImageIOHandler* self) {
|
|
return self->canRead();
|
|
}
|
|
|
|
bool QImageIOHandler_read(QImageIOHandler* self, QImage* image) {
|
|
return self->read(image);
|
|
}
|
|
|
|
bool QImageIOHandler_write(QImageIOHandler* self, QImage* image) {
|
|
return self->write(*image);
|
|
}
|
|
|
|
QVariant* QImageIOHandler_option(const QImageIOHandler* self, int option) {
|
|
return new QVariant(self->option(static_cast<QImageIOHandler::ImageOption>(option)));
|
|
}
|
|
|
|
void QImageIOHandler_setOption(QImageIOHandler* self, int option, QVariant* value) {
|
|
self->setOption(static_cast<QImageIOHandler::ImageOption>(option), *value);
|
|
}
|
|
|
|
bool QImageIOHandler_supportsOption(const QImageIOHandler* self, int option) {
|
|
return self->supportsOption(static_cast<QImageIOHandler::ImageOption>(option));
|
|
}
|
|
|
|
bool QImageIOHandler_jumpToNextImage(QImageIOHandler* self) {
|
|
return self->jumpToNextImage();
|
|
}
|
|
|
|
bool QImageIOHandler_jumpToImage(QImageIOHandler* self, int imageNumber) {
|
|
return self->jumpToImage(static_cast<int>(imageNumber));
|
|
}
|
|
|
|
int QImageIOHandler_loopCount(const QImageIOHandler* self) {
|
|
return self->loopCount();
|
|
}
|
|
|
|
int QImageIOHandler_imageCount(const QImageIOHandler* self) {
|
|
return self->imageCount();
|
|
}
|
|
|
|
int QImageIOHandler_nextImageDelay(const QImageIOHandler* self) {
|
|
return self->nextImageDelay();
|
|
}
|
|
|
|
int QImageIOHandler_currentImageNumber(const QImageIOHandler* self) {
|
|
return self->currentImageNumber();
|
|
}
|
|
|
|
QRect* QImageIOHandler_currentImageRect(const QImageIOHandler* self) {
|
|
return new QRect(self->currentImageRect());
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_name(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__name = slot;
|
|
return true;
|
|
}
|
|
|
|
struct miqt_string QImageIOHandler_virtualbase_name(const void* self) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_name();
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_canRead(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__canRead = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_read(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__read = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_write(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__write = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOHandler_virtualbase_write(void* self, QImage* image) {
|
|
return ( (MiqtVirtualQImageIOHandler*)(self) )->virtualbase_write(image);
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_option(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__option = slot;
|
|
return true;
|
|
}
|
|
|
|
QVariant* QImageIOHandler_virtualbase_option(const void* self, int option) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_option(option);
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_setOption(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__setOption = slot;
|
|
return true;
|
|
}
|
|
|
|
void QImageIOHandler_virtualbase_setOption(void* self, int option, QVariant* value) {
|
|
( (MiqtVirtualQImageIOHandler*)(self) )->virtualbase_setOption(option, value);
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_supportsOption(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__supportsOption = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOHandler_virtualbase_supportsOption(const void* self, int option) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_supportsOption(option);
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_jumpToNextImage(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__jumpToNextImage = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOHandler_virtualbase_jumpToNextImage(void* self) {
|
|
return ( (MiqtVirtualQImageIOHandler*)(self) )->virtualbase_jumpToNextImage();
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_jumpToImage(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__jumpToImage = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOHandler_virtualbase_jumpToImage(void* self, int imageNumber) {
|
|
return ( (MiqtVirtualQImageIOHandler*)(self) )->virtualbase_jumpToImage(imageNumber);
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_loopCount(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__loopCount = slot;
|
|
return true;
|
|
}
|
|
|
|
int QImageIOHandler_virtualbase_loopCount(const void* self) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_loopCount();
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_imageCount(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__imageCount = slot;
|
|
return true;
|
|
}
|
|
|
|
int QImageIOHandler_virtualbase_imageCount(const void* self) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_imageCount();
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_nextImageDelay(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__nextImageDelay = slot;
|
|
return true;
|
|
}
|
|
|
|
int QImageIOHandler_virtualbase_nextImageDelay(const void* self) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_nextImageDelay();
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_currentImageNumber(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__currentImageNumber = slot;
|
|
return true;
|
|
}
|
|
|
|
int QImageIOHandler_virtualbase_currentImageNumber(const void* self) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_currentImageNumber();
|
|
}
|
|
|
|
bool QImageIOHandler_override_virtual_currentImageRect(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOHandler* self_cast = dynamic_cast<MiqtVirtualQImageIOHandler*>( (QImageIOHandler*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__currentImageRect = slot;
|
|
return true;
|
|
}
|
|
|
|
QRect* QImageIOHandler_virtualbase_currentImageRect(const void* self) {
|
|
return ( (const MiqtVirtualQImageIOHandler*)(self) )->virtualbase_currentImageRect();
|
|
}
|
|
|
|
void QImageIOHandler_delete(QImageIOHandler* self) {
|
|
delete self;
|
|
}
|
|
|
|
class MiqtVirtualQImageIOPlugin final : public QImageIOPlugin {
|
|
public:
|
|
|
|
MiqtVirtualQImageIOPlugin(): QImageIOPlugin() {};
|
|
MiqtVirtualQImageIOPlugin(QObject* parent): QImageIOPlugin(parent) {};
|
|
|
|
virtual ~MiqtVirtualQImageIOPlugin() override = default;
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__capabilities = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QImageIOPlugin::Capabilities capabilities(QIODevice* device, const QByteArray& format) const override {
|
|
if (handle__capabilities == 0) {
|
|
return QImageIOPlugin::Capabilities(); // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
QIODevice* sigval1 = device;
|
|
const QByteArray format_qb = format;
|
|
struct miqt_string format_ms;
|
|
format_ms.len = format_qb.length();
|
|
format_ms.data = static_cast<char*>(malloc(format_ms.len));
|
|
memcpy(format_ms.data, format_qb.data(), format_ms.len);
|
|
struct miqt_string sigval2 = format_ms;
|
|
|
|
int callback_return_value = miqt_exec_callback_QImageIOPlugin_capabilities(this, handle__capabilities, sigval1, sigval2);
|
|
|
|
return static_cast<QImageIOPlugin::Capabilities>(callback_return_value);
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__create = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual QImageIOHandler* create(QIODevice* device, const QByteArray& format) const override {
|
|
if (handle__create == 0) {
|
|
return nullptr; // Pure virtual, there is no base we can call
|
|
}
|
|
|
|
QIODevice* sigval1 = device;
|
|
const QByteArray format_qb = format;
|
|
struct miqt_string format_ms;
|
|
format_ms.len = format_qb.length();
|
|
format_ms.data = static_cast<char*>(malloc(format_ms.len));
|
|
memcpy(format_ms.data, format_qb.data(), format_ms.len);
|
|
struct miqt_string sigval2 = format_ms;
|
|
|
|
QImageIOHandler* callback_return_value = miqt_exec_callback_QImageIOPlugin_create(this, handle__create, sigval1, sigval2);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__event = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool event(QEvent* event) override {
|
|
if (handle__event == 0) {
|
|
return QImageIOPlugin::event(event);
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOPlugin_event(this, handle__event, sigval1);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
bool virtualbase_event(QEvent* event) {
|
|
|
|
return QImageIOPlugin::event(event);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__eventFilter = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual bool eventFilter(QObject* watched, QEvent* event) override {
|
|
if (handle__eventFilter == 0) {
|
|
return QImageIOPlugin::eventFilter(watched, event);
|
|
}
|
|
|
|
QObject* sigval1 = watched;
|
|
QEvent* sigval2 = event;
|
|
|
|
bool callback_return_value = miqt_exec_callback_QImageIOPlugin_eventFilter(this, handle__eventFilter, sigval1, sigval2);
|
|
|
|
return callback_return_value;
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
bool virtualbase_eventFilter(QObject* watched, QEvent* event) {
|
|
|
|
return QImageIOPlugin::eventFilter(watched, event);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__timerEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void timerEvent(QTimerEvent* event) override {
|
|
if (handle__timerEvent == 0) {
|
|
QImageIOPlugin::timerEvent(event);
|
|
return;
|
|
}
|
|
|
|
QTimerEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_QImageIOPlugin_timerEvent(this, handle__timerEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_timerEvent(QTimerEvent* event) {
|
|
|
|
QImageIOPlugin::timerEvent(event);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__childEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void childEvent(QChildEvent* event) override {
|
|
if (handle__childEvent == 0) {
|
|
QImageIOPlugin::childEvent(event);
|
|
return;
|
|
}
|
|
|
|
QChildEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_QImageIOPlugin_childEvent(this, handle__childEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_childEvent(QChildEvent* event) {
|
|
|
|
QImageIOPlugin::childEvent(event);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__customEvent = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void customEvent(QEvent* event) override {
|
|
if (handle__customEvent == 0) {
|
|
QImageIOPlugin::customEvent(event);
|
|
return;
|
|
}
|
|
|
|
QEvent* sigval1 = event;
|
|
|
|
miqt_exec_callback_QImageIOPlugin_customEvent(this, handle__customEvent, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_customEvent(QEvent* event) {
|
|
|
|
QImageIOPlugin::customEvent(event);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__connectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void connectNotify(const QMetaMethod& signal) override {
|
|
if (handle__connectNotify == 0) {
|
|
QImageIOPlugin::connectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_QImageIOPlugin_connectNotify(this, handle__connectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_connectNotify(QMetaMethod* signal) {
|
|
|
|
QImageIOPlugin::connectNotify(*signal);
|
|
|
|
}
|
|
|
|
// cgo.Handle value for overwritten implementation
|
|
intptr_t handle__disconnectNotify = 0;
|
|
|
|
// Subclass to allow providing a Go implementation
|
|
virtual void disconnectNotify(const QMetaMethod& signal) override {
|
|
if (handle__disconnectNotify == 0) {
|
|
QImageIOPlugin::disconnectNotify(signal);
|
|
return;
|
|
}
|
|
|
|
const QMetaMethod& signal_ret = signal;
|
|
// Cast returned reference into pointer
|
|
QMetaMethod* sigval1 = const_cast<QMetaMethod*>(&signal_ret);
|
|
|
|
miqt_exec_callback_QImageIOPlugin_disconnectNotify(this, handle__disconnectNotify, sigval1);
|
|
|
|
|
|
}
|
|
|
|
// Wrapper to allow calling protected method
|
|
void virtualbase_disconnectNotify(QMetaMethod* signal) {
|
|
|
|
QImageIOPlugin::disconnectNotify(*signal);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
QImageIOPlugin* QImageIOPlugin_new() {
|
|
return new MiqtVirtualQImageIOPlugin();
|
|
}
|
|
|
|
QImageIOPlugin* QImageIOPlugin_new2(QObject* parent) {
|
|
return new MiqtVirtualQImageIOPlugin(parent);
|
|
}
|
|
|
|
void QImageIOPlugin_virtbase(QImageIOPlugin* src, QObject** outptr_QObject) {
|
|
*outptr_QObject = static_cast<QObject*>(src);
|
|
}
|
|
|
|
QMetaObject* QImageIOPlugin_metaObject(const QImageIOPlugin* self) {
|
|
return (QMetaObject*) self->metaObject();
|
|
}
|
|
|
|
void* QImageIOPlugin_metacast(QImageIOPlugin* self, const char* param1) {
|
|
return self->qt_metacast(param1);
|
|
}
|
|
|
|
struct miqt_string QImageIOPlugin_tr(const char* s) {
|
|
QString _ret = QImageIOPlugin::tr(s);
|
|
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
|
|
QByteArray _b = _ret.toUtf8();
|
|
struct miqt_string _ms;
|
|
_ms.len = _b.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
struct miqt_string QImageIOPlugin_trUtf8(const char* s) {
|
|
QString _ret = QImageIOPlugin::trUtf8(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;
|
|
}
|
|
|
|
int QImageIOPlugin_capabilities(const QImageIOPlugin* self, QIODevice* device, struct miqt_string format) {
|
|
QByteArray format_QByteArray(format.data, format.len);
|
|
QImageIOPlugin::Capabilities _ret = self->capabilities(device, format_QByteArray);
|
|
return static_cast<int>(_ret);
|
|
}
|
|
|
|
QImageIOHandler* QImageIOPlugin_create(const QImageIOPlugin* self, QIODevice* device, struct miqt_string format) {
|
|
QByteArray format_QByteArray(format.data, format.len);
|
|
return self->create(device, format_QByteArray);
|
|
}
|
|
|
|
struct miqt_string QImageIOPlugin_tr2(const char* s, const char* c) {
|
|
QString _ret = QImageIOPlugin::tr(s, c);
|
|
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
|
|
QByteArray _b = _ret.toUtf8();
|
|
struct miqt_string _ms;
|
|
_ms.len = _b.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
struct miqt_string QImageIOPlugin_tr3(const char* s, const char* c, int n) {
|
|
QString _ret = QImageIOPlugin::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;
|
|
}
|
|
|
|
struct miqt_string QImageIOPlugin_trUtf82(const char* s, const char* c) {
|
|
QString _ret = QImageIOPlugin::trUtf8(s, c);
|
|
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
|
|
QByteArray _b = _ret.toUtf8();
|
|
struct miqt_string _ms;
|
|
_ms.len = _b.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
struct miqt_string QImageIOPlugin_trUtf83(const char* s, const char* c, int n) {
|
|
QString _ret = QImageIOPlugin::trUtf8(s, c, static_cast<int>(n));
|
|
// Convert QString from UTF-16 in C++ RAII memory to UTF-8 in manually-managed C memory
|
|
QByteArray _b = _ret.toUtf8();
|
|
struct miqt_string _ms;
|
|
_ms.len = _b.length();
|
|
_ms.data = static_cast<char*>(malloc(_ms.len));
|
|
memcpy(_ms.data, _b.data(), _ms.len);
|
|
return _ms;
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_capabilities(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__capabilities = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_create(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__create = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_event(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__event = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOPlugin_virtualbase_event(void* self, QEvent* event) {
|
|
return ( (MiqtVirtualQImageIOPlugin*)(self) )->virtualbase_event(event);
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_eventFilter(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__eventFilter = slot;
|
|
return true;
|
|
}
|
|
|
|
bool QImageIOPlugin_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event) {
|
|
return ( (MiqtVirtualQImageIOPlugin*)(self) )->virtualbase_eventFilter(watched, event);
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_timerEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__timerEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void QImageIOPlugin_virtualbase_timerEvent(void* self, QTimerEvent* event) {
|
|
( (MiqtVirtualQImageIOPlugin*)(self) )->virtualbase_timerEvent(event);
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_childEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__childEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void QImageIOPlugin_virtualbase_childEvent(void* self, QChildEvent* event) {
|
|
( (MiqtVirtualQImageIOPlugin*)(self) )->virtualbase_childEvent(event);
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_customEvent(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__customEvent = slot;
|
|
return true;
|
|
}
|
|
|
|
void QImageIOPlugin_virtualbase_customEvent(void* self, QEvent* event) {
|
|
( (MiqtVirtualQImageIOPlugin*)(self) )->virtualbase_customEvent(event);
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_connectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__connectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void QImageIOPlugin_virtualbase_connectNotify(void* self, QMetaMethod* signal) {
|
|
( (MiqtVirtualQImageIOPlugin*)(self) )->virtualbase_connectNotify(signal);
|
|
}
|
|
|
|
bool QImageIOPlugin_override_virtual_disconnectNotify(void* self, intptr_t slot) {
|
|
MiqtVirtualQImageIOPlugin* self_cast = dynamic_cast<MiqtVirtualQImageIOPlugin*>( (QImageIOPlugin*)(self) );
|
|
if (self_cast == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
self_cast->handle__disconnectNotify = slot;
|
|
return true;
|
|
}
|
|
|
|
void QImageIOPlugin_virtualbase_disconnectNotify(void* self, QMetaMethod* signal) {
|
|
( (MiqtVirtualQImageIOPlugin*)(self) )->virtualbase_disconnectNotify(signal);
|
|
}
|
|
|
|
void QImageIOPlugin_delete(QImageIOPlugin* self) {
|
|
delete self;
|
|
}
|
|
|