minor cleanup internal/templater

This commit is contained in:
therecipe 2016-12-14 21:12:51 +01:00
parent cae2cd564b
commit e6da611e3d
38 changed files with 16664 additions and 246 deletions

View file

@ -54,6 +54,8 @@
#include <QMouseEvent>
#include <QMoveEvent>
#include <QObject>
#include <QPaintDevice>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPixmap>
#include <QPoint>
@ -253,8 +255,11 @@ public:
void customEvent(QEvent * event) { callbackQDesignerActionEditorInterface_CustomEvent(this, event); };
void deleteLater() { callbackQDesignerActionEditorInterface_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDesignerActionEditorInterface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQDesignerActionEditorInterface_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesignerActionEditorInterface_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDesignerActionEditorInterface_MetaObject(const_cast<MyQDesignerActionEditorInterface*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQDesignerActionEditorInterface_Metric(const_cast<MyQDesignerActionEditorInterface*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQDesignerActionEditorInterface_PaintEngine(const_cast<MyQDesignerActionEditorInterface*>(this))); };
};
void* QDesignerActionEditorInterface_NewQDesignerActionEditorInterface(void* parent, long long flags)
@ -889,6 +894,16 @@ void QDesignerActionEditorInterface_DisconnectNotifyDefault(void* ptr, void* sig
static_cast<QDesignerActionEditorInterface*>(ptr)->QDesignerActionEditorInterface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QDesignerActionEditorInterface_Event(void* ptr, void* e)
{
return static_cast<QDesignerActionEditorInterface*>(ptr)->event(static_cast<QEvent*>(e));
}
char QDesignerActionEditorInterface_EventDefault(void* ptr, void* e)
{
return static_cast<QDesignerActionEditorInterface*>(ptr)->QDesignerActionEditorInterface::event(static_cast<QEvent*>(e));
}
char QDesignerActionEditorInterface_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDesignerActionEditorInterface*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -909,6 +924,26 @@ void* QDesignerActionEditorInterface_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QDesignerActionEditorInterface*>(ptr)->QDesignerActionEditorInterface::metaObject());
}
int QDesignerActionEditorInterface_Metric(void* ptr, long long metric)
{
return static_cast<QDesignerActionEditorInterface*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QDesignerActionEditorInterface_MetricDefault(void* ptr, long long metric)
{
return static_cast<QDesignerActionEditorInterface*>(ptr)->QDesignerActionEditorInterface::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QDesignerActionEditorInterface_PaintEngine(void* ptr)
{
return static_cast<QDesignerActionEditorInterface*>(ptr)->paintEngine();
}
void* QDesignerActionEditorInterface_PaintEngineDefault(void* ptr)
{
return static_cast<QDesignerActionEditorInterface*>(ptr)->QDesignerActionEditorInterface::paintEngine();
}
class MyQDesignerContainerExtension: public QDesignerContainerExtension
{
public:
@ -1564,8 +1599,11 @@ public:
void customEvent(QEvent * event) { callbackQDesignerFormWindowInterface_CustomEvent(this, event); };
void deleteLater() { callbackQDesignerFormWindowInterface_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDesignerFormWindowInterface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQDesignerFormWindowInterface_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesignerFormWindowInterface_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDesignerFormWindowInterface_MetaObject(const_cast<MyQDesignerFormWindowInterface*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQDesignerFormWindowInterface_Metric(const_cast<MyQDesignerFormWindowInterface*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQDesignerFormWindowInterface_PaintEngine(const_cast<MyQDesignerFormWindowInterface*>(this))); };
};
void* QDesignerFormWindowInterface_QDesignerFormWindowInterface_FindFormWindow2(void* object)
@ -2607,6 +2645,16 @@ void QDesignerFormWindowInterface_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QDesignerFormWindowInterface*>(ptr)->QDesignerFormWindowInterface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QDesignerFormWindowInterface_Event(void* ptr, void* e)
{
return static_cast<QDesignerFormWindowInterface*>(ptr)->event(static_cast<QEvent*>(e));
}
char QDesignerFormWindowInterface_EventDefault(void* ptr, void* e)
{
return static_cast<QDesignerFormWindowInterface*>(ptr)->QDesignerFormWindowInterface::event(static_cast<QEvent*>(e));
}
char QDesignerFormWindowInterface_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDesignerFormWindowInterface*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -2627,6 +2675,26 @@ void* QDesignerFormWindowInterface_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QDesignerFormWindowInterface*>(ptr)->QDesignerFormWindowInterface::metaObject());
}
int QDesignerFormWindowInterface_Metric(void* ptr, long long metric)
{
return static_cast<QDesignerFormWindowInterface*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QDesignerFormWindowInterface_MetricDefault(void* ptr, long long metric)
{
return static_cast<QDesignerFormWindowInterface*>(ptr)->QDesignerFormWindowInterface::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QDesignerFormWindowInterface_PaintEngine(void* ptr)
{
return static_cast<QDesignerFormWindowInterface*>(ptr)->paintEngine();
}
void* QDesignerFormWindowInterface_PaintEngineDefault(void* ptr)
{
return static_cast<QDesignerFormWindowInterface*>(ptr)->QDesignerFormWindowInterface::paintEngine();
}
class MyQDesignerFormWindowManagerInterface: public QDesignerFormWindowManagerInterface
{
public:
@ -3054,8 +3122,11 @@ public:
void customEvent(QEvent * event) { callbackQDesignerObjectInspectorInterface_CustomEvent(this, event); };
void deleteLater() { callbackQDesignerObjectInspectorInterface_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDesignerObjectInspectorInterface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQDesignerObjectInspectorInterface_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesignerObjectInspectorInterface_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDesignerObjectInspectorInterface_MetaObject(const_cast<MyQDesignerObjectInspectorInterface*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQDesignerObjectInspectorInterface_Metric(const_cast<MyQDesignerObjectInspectorInterface*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQDesignerObjectInspectorInterface_PaintEngine(const_cast<MyQDesignerObjectInspectorInterface*>(this))); };
};
void* QDesignerObjectInspectorInterface_NewQDesignerObjectInspectorInterface(void* parent, long long flags)
@ -3680,6 +3751,16 @@ void QDesignerObjectInspectorInterface_DisconnectNotifyDefault(void* ptr, void*
static_cast<QDesignerObjectInspectorInterface*>(ptr)->QDesignerObjectInspectorInterface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QDesignerObjectInspectorInterface_Event(void* ptr, void* e)
{
return static_cast<QDesignerObjectInspectorInterface*>(ptr)->event(static_cast<QEvent*>(e));
}
char QDesignerObjectInspectorInterface_EventDefault(void* ptr, void* e)
{
return static_cast<QDesignerObjectInspectorInterface*>(ptr)->QDesignerObjectInspectorInterface::event(static_cast<QEvent*>(e));
}
char QDesignerObjectInspectorInterface_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDesignerObjectInspectorInterface*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -3700,6 +3781,26 @@ void* QDesignerObjectInspectorInterface_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QDesignerObjectInspectorInterface*>(ptr)->QDesignerObjectInspectorInterface::metaObject());
}
int QDesignerObjectInspectorInterface_Metric(void* ptr, long long metric)
{
return static_cast<QDesignerObjectInspectorInterface*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QDesignerObjectInspectorInterface_MetricDefault(void* ptr, long long metric)
{
return static_cast<QDesignerObjectInspectorInterface*>(ptr)->QDesignerObjectInspectorInterface::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QDesignerObjectInspectorInterface_PaintEngine(void* ptr)
{
return static_cast<QDesignerObjectInspectorInterface*>(ptr)->paintEngine();
}
void* QDesignerObjectInspectorInterface_PaintEngineDefault(void* ptr)
{
return static_cast<QDesignerObjectInspectorInterface*>(ptr)->QDesignerObjectInspectorInterface::paintEngine();
}
class MyQDesignerPropertyEditorInterface: public QDesignerPropertyEditorInterface
{
public:
@ -3772,8 +3873,11 @@ public:
void customEvent(QEvent * event) { callbackQDesignerPropertyEditorInterface_CustomEvent(this, event); };
void deleteLater() { callbackQDesignerPropertyEditorInterface_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDesignerPropertyEditorInterface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQDesignerPropertyEditorInterface_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesignerPropertyEditorInterface_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDesignerPropertyEditorInterface_MetaObject(const_cast<MyQDesignerPropertyEditorInterface*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQDesignerPropertyEditorInterface_Metric(const_cast<MyQDesignerPropertyEditorInterface*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQDesignerPropertyEditorInterface_PaintEngine(const_cast<MyQDesignerPropertyEditorInterface*>(this))); };
};
void* QDesignerPropertyEditorInterface_NewQDesignerPropertyEditorInterface(void* parent, long long flags)
@ -4438,6 +4542,16 @@ void QDesignerPropertyEditorInterface_DisconnectNotifyDefault(void* ptr, void* s
static_cast<QDesignerPropertyEditorInterface*>(ptr)->QDesignerPropertyEditorInterface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QDesignerPropertyEditorInterface_Event(void* ptr, void* e)
{
return static_cast<QDesignerPropertyEditorInterface*>(ptr)->event(static_cast<QEvent*>(e));
}
char QDesignerPropertyEditorInterface_EventDefault(void* ptr, void* e)
{
return static_cast<QDesignerPropertyEditorInterface*>(ptr)->QDesignerPropertyEditorInterface::event(static_cast<QEvent*>(e));
}
char QDesignerPropertyEditorInterface_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDesignerPropertyEditorInterface*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -4458,6 +4572,26 @@ void* QDesignerPropertyEditorInterface_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QDesignerPropertyEditorInterface*>(ptr)->QDesignerPropertyEditorInterface::metaObject());
}
int QDesignerPropertyEditorInterface_Metric(void* ptr, long long metric)
{
return static_cast<QDesignerPropertyEditorInterface*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QDesignerPropertyEditorInterface_MetricDefault(void* ptr, long long metric)
{
return static_cast<QDesignerPropertyEditorInterface*>(ptr)->QDesignerPropertyEditorInterface::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QDesignerPropertyEditorInterface_PaintEngine(void* ptr)
{
return static_cast<QDesignerPropertyEditorInterface*>(ptr)->paintEngine();
}
void* QDesignerPropertyEditorInterface_PaintEngineDefault(void* ptr)
{
return static_cast<QDesignerPropertyEditorInterface*>(ptr)->QDesignerPropertyEditorInterface::paintEngine();
}
class MyQDesignerPropertySheetExtension: public QDesignerPropertySheetExtension
{
public:
@ -4674,8 +4808,11 @@ public:
void customEvent(QEvent * event) { callbackQDesignerWidgetBoxInterface_CustomEvent(this, event); };
void deleteLater() { callbackQDesignerWidgetBoxInterface_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQDesignerWidgetBoxInterface_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQDesignerWidgetBoxInterface_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQDesignerWidgetBoxInterface_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQDesignerWidgetBoxInterface_MetaObject(const_cast<MyQDesignerWidgetBoxInterface*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQDesignerWidgetBoxInterface_Metric(const_cast<MyQDesignerWidgetBoxInterface*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQDesignerWidgetBoxInterface_PaintEngine(const_cast<MyQDesignerWidgetBoxInterface*>(this))); };
};
struct QtDesigner_PackedString QDesignerWidgetBoxInterface_FileName(void* ptr)
@ -5300,6 +5437,16 @@ void QDesignerWidgetBoxInterface_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QDesignerWidgetBoxInterface*>(ptr)->QDesignerWidgetBoxInterface::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QDesignerWidgetBoxInterface_Event(void* ptr, void* e)
{
return static_cast<QDesignerWidgetBoxInterface*>(ptr)->event(static_cast<QEvent*>(e));
}
char QDesignerWidgetBoxInterface_EventDefault(void* ptr, void* e)
{
return static_cast<QDesignerWidgetBoxInterface*>(ptr)->QDesignerWidgetBoxInterface::event(static_cast<QEvent*>(e));
}
char QDesignerWidgetBoxInterface_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QDesignerWidgetBoxInterface*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -5320,6 +5467,26 @@ void* QDesignerWidgetBoxInterface_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QDesignerWidgetBoxInterface*>(ptr)->QDesignerWidgetBoxInterface::metaObject());
}
int QDesignerWidgetBoxInterface_Metric(void* ptr, long long metric)
{
return static_cast<QDesignerWidgetBoxInterface*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QDesignerWidgetBoxInterface_MetricDefault(void* ptr, long long metric)
{
return static_cast<QDesignerWidgetBoxInterface*>(ptr)->QDesignerWidgetBoxInterface::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QDesignerWidgetBoxInterface_PaintEngine(void* ptr)
{
return static_cast<QDesignerWidgetBoxInterface*>(ptr)->paintEngine();
}
void* QDesignerWidgetBoxInterface_PaintEngineDefault(void* ptr)
{
return static_cast<QDesignerWidgetBoxInterface*>(ptr)->QDesignerWidgetBoxInterface::paintEngine();
}
class MyQExtensionFactory: public QExtensionFactory
{
public:

View file

@ -2863,6 +2863,44 @@ func (ptr *QDesignerActionEditorInterface) DisconnectNotifyDefault(sign core.QMe
}
}
//export callbackQDesignerActionEditorInterface_Event
func callbackQDesignerActionEditorInterface_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerActionEditorInterface::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQDesignerActionEditorInterfaceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QDesignerActionEditorInterface) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerActionEditorInterface::event", f)
}
}
func (ptr *QDesignerActionEditorInterface) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerActionEditorInterface::event")
}
}
func (ptr *QDesignerActionEditorInterface) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerActionEditorInterface_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QDesignerActionEditorInterface) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerActionEditorInterface_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQDesignerActionEditorInterface_EventFilter
func callbackQDesignerActionEditorInterface_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -2939,6 +2977,82 @@ func (ptr *QDesignerActionEditorInterface) MetaObjectDefault() *core.QMetaObject
return nil
}
//export callbackQDesignerActionEditorInterface_Metric
func callbackQDesignerActionEditorInterface_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerActionEditorInterface::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQDesignerActionEditorInterfaceFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QDesignerActionEditorInterface) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerActionEditorInterface::metric", f)
}
}
func (ptr *QDesignerActionEditorInterface) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerActionEditorInterface::metric")
}
}
func (ptr *QDesignerActionEditorInterface) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerActionEditorInterface_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QDesignerActionEditorInterface) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerActionEditorInterface_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQDesignerActionEditorInterface_PaintEngine
func callbackQDesignerActionEditorInterface_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerActionEditorInterface::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQDesignerActionEditorInterfaceFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QDesignerActionEditorInterface) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerActionEditorInterface::paintEngine", f)
}
}
func (ptr *QDesignerActionEditorInterface) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerActionEditorInterface::paintEngine")
}
}
func (ptr *QDesignerActionEditorInterface) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerActionEditorInterface_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QDesignerActionEditorInterface) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerActionEditorInterface_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QDesignerContainerExtension struct {
ptr unsafe.Pointer
}
@ -9187,6 +9301,44 @@ func (ptr *QDesignerFormWindowInterface) DisconnectNotifyDefault(sign core.QMeta
}
}
//export callbackQDesignerFormWindowInterface_Event
func callbackQDesignerFormWindowInterface_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerFormWindowInterface::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQDesignerFormWindowInterfaceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QDesignerFormWindowInterface) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerFormWindowInterface::event", f)
}
}
func (ptr *QDesignerFormWindowInterface) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerFormWindowInterface::event")
}
}
func (ptr *QDesignerFormWindowInterface) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerFormWindowInterface_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QDesignerFormWindowInterface) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerFormWindowInterface_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQDesignerFormWindowInterface_EventFilter
func callbackQDesignerFormWindowInterface_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -9263,6 +9415,82 @@ func (ptr *QDesignerFormWindowInterface) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQDesignerFormWindowInterface_Metric
func callbackQDesignerFormWindowInterface_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerFormWindowInterface::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQDesignerFormWindowInterfaceFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QDesignerFormWindowInterface) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerFormWindowInterface::metric", f)
}
}
func (ptr *QDesignerFormWindowInterface) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerFormWindowInterface::metric")
}
}
func (ptr *QDesignerFormWindowInterface) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerFormWindowInterface_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QDesignerFormWindowInterface) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerFormWindowInterface_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQDesignerFormWindowInterface_PaintEngine
func callbackQDesignerFormWindowInterface_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerFormWindowInterface::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQDesignerFormWindowInterfaceFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QDesignerFormWindowInterface) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerFormWindowInterface::paintEngine", f)
}
}
func (ptr *QDesignerFormWindowInterface) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerFormWindowInterface::paintEngine")
}
}
func (ptr *QDesignerFormWindowInterface) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerFormWindowInterface_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QDesignerFormWindowInterface) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerFormWindowInterface_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//QDesignerFormWindowManagerInterface::Action
type QDesignerFormWindowManagerInterface__Action int64
@ -13037,6 +13265,44 @@ func (ptr *QDesignerObjectInspectorInterface) DisconnectNotifyDefault(sign core.
}
}
//export callbackQDesignerObjectInspectorInterface_Event
func callbackQDesignerObjectInspectorInterface_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerObjectInspectorInterface::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQDesignerObjectInspectorInterfaceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QDesignerObjectInspectorInterface) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerObjectInspectorInterface::event", f)
}
}
func (ptr *QDesignerObjectInspectorInterface) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerObjectInspectorInterface::event")
}
}
func (ptr *QDesignerObjectInspectorInterface) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerObjectInspectorInterface_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QDesignerObjectInspectorInterface) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerObjectInspectorInterface_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQDesignerObjectInspectorInterface_EventFilter
func callbackQDesignerObjectInspectorInterface_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -13113,6 +13379,82 @@ func (ptr *QDesignerObjectInspectorInterface) MetaObjectDefault() *core.QMetaObj
return nil
}
//export callbackQDesignerObjectInspectorInterface_Metric
func callbackQDesignerObjectInspectorInterface_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerObjectInspectorInterface::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQDesignerObjectInspectorInterfaceFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QDesignerObjectInspectorInterface) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerObjectInspectorInterface::metric", f)
}
}
func (ptr *QDesignerObjectInspectorInterface) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerObjectInspectorInterface::metric")
}
}
func (ptr *QDesignerObjectInspectorInterface) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerObjectInspectorInterface_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QDesignerObjectInspectorInterface) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerObjectInspectorInterface_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQDesignerObjectInspectorInterface_PaintEngine
func callbackQDesignerObjectInspectorInterface_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerObjectInspectorInterface::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQDesignerObjectInspectorInterfaceFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QDesignerObjectInspectorInterface) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerObjectInspectorInterface::paintEngine", f)
}
}
func (ptr *QDesignerObjectInspectorInterface) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerObjectInspectorInterface::paintEngine")
}
}
func (ptr *QDesignerObjectInspectorInterface) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerObjectInspectorInterface_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QDesignerObjectInspectorInterface) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerObjectInspectorInterface_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QDesignerPropertyEditorInterface struct {
widgets.QWidget
}
@ -15602,6 +15944,44 @@ func (ptr *QDesignerPropertyEditorInterface) DisconnectNotifyDefault(sign core.Q
}
}
//export callbackQDesignerPropertyEditorInterface_Event
func callbackQDesignerPropertyEditorInterface_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerPropertyEditorInterface::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQDesignerPropertyEditorInterfaceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QDesignerPropertyEditorInterface) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerPropertyEditorInterface::event", f)
}
}
func (ptr *QDesignerPropertyEditorInterface) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerPropertyEditorInterface::event")
}
}
func (ptr *QDesignerPropertyEditorInterface) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerPropertyEditorInterface_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QDesignerPropertyEditorInterface) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerPropertyEditorInterface_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQDesignerPropertyEditorInterface_EventFilter
func callbackQDesignerPropertyEditorInterface_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -15678,6 +16058,82 @@ func (ptr *QDesignerPropertyEditorInterface) MetaObjectDefault() *core.QMetaObje
return nil
}
//export callbackQDesignerPropertyEditorInterface_Metric
func callbackQDesignerPropertyEditorInterface_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerPropertyEditorInterface::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQDesignerPropertyEditorInterfaceFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QDesignerPropertyEditorInterface) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerPropertyEditorInterface::metric", f)
}
}
func (ptr *QDesignerPropertyEditorInterface) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerPropertyEditorInterface::metric")
}
}
func (ptr *QDesignerPropertyEditorInterface) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerPropertyEditorInterface_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QDesignerPropertyEditorInterface) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerPropertyEditorInterface_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQDesignerPropertyEditorInterface_PaintEngine
func callbackQDesignerPropertyEditorInterface_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerPropertyEditorInterface::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQDesignerPropertyEditorInterfaceFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QDesignerPropertyEditorInterface) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerPropertyEditorInterface::paintEngine", f)
}
}
func (ptr *QDesignerPropertyEditorInterface) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerPropertyEditorInterface::paintEngine")
}
}
func (ptr *QDesignerPropertyEditorInterface) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerPropertyEditorInterface_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QDesignerPropertyEditorInterface) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerPropertyEditorInterface_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QDesignerPropertySheetExtension struct {
ptr unsafe.Pointer
}
@ -18736,6 +19192,44 @@ func (ptr *QDesignerWidgetBoxInterface) DisconnectNotifyDefault(sign core.QMetaM
}
}
//export callbackQDesignerWidgetBoxInterface_Event
func callbackQDesignerWidgetBoxInterface_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerWidgetBoxInterface::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQDesignerWidgetBoxInterfaceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QDesignerWidgetBoxInterface) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerWidgetBoxInterface::event", f)
}
}
func (ptr *QDesignerWidgetBoxInterface) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerWidgetBoxInterface::event")
}
}
func (ptr *QDesignerWidgetBoxInterface) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerWidgetBoxInterface_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QDesignerWidgetBoxInterface) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QDesignerWidgetBoxInterface_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQDesignerWidgetBoxInterface_EventFilter
func callbackQDesignerWidgetBoxInterface_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -18812,6 +19306,82 @@ func (ptr *QDesignerWidgetBoxInterface) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQDesignerWidgetBoxInterface_Metric
func callbackQDesignerWidgetBoxInterface_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerWidgetBoxInterface::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQDesignerWidgetBoxInterfaceFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QDesignerWidgetBoxInterface) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerWidgetBoxInterface::metric", f)
}
}
func (ptr *QDesignerWidgetBoxInterface) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerWidgetBoxInterface::metric")
}
}
func (ptr *QDesignerWidgetBoxInterface) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerWidgetBoxInterface_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QDesignerWidgetBoxInterface) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QDesignerWidgetBoxInterface_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQDesignerWidgetBoxInterface_PaintEngine
func callbackQDesignerWidgetBoxInterface_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QDesignerWidgetBoxInterface::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQDesignerWidgetBoxInterfaceFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QDesignerWidgetBoxInterface) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerWidgetBoxInterface::paintEngine", f)
}
}
func (ptr *QDesignerWidgetBoxInterface) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QDesignerWidgetBoxInterface::paintEngine")
}
}
func (ptr *QDesignerWidgetBoxInterface) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerWidgetBoxInterface_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QDesignerWidgetBoxInterface) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QDesignerWidgetBoxInterface_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QExtensionFactory struct {
core.QObject
QAbstractExtensionFactory

View file

@ -157,10 +157,16 @@ void QDesignerActionEditorInterface_DeleteLater(void* ptr);
void QDesignerActionEditorInterface_DeleteLaterDefault(void* ptr);
void QDesignerActionEditorInterface_DisconnectNotify(void* ptr, void* sign);
void QDesignerActionEditorInterface_DisconnectNotifyDefault(void* ptr, void* sign);
char QDesignerActionEditorInterface_Event(void* ptr, void* e);
char QDesignerActionEditorInterface_EventDefault(void* ptr, void* e);
char QDesignerActionEditorInterface_EventFilter(void* ptr, void* watched, void* event);
char QDesignerActionEditorInterface_EventFilterDefault(void* ptr, void* watched, void* event);
void* QDesignerActionEditorInterface_MetaObject(void* ptr);
void* QDesignerActionEditorInterface_MetaObjectDefault(void* ptr);
int QDesignerActionEditorInterface_Metric(void* ptr, long long metric);
int QDesignerActionEditorInterface_MetricDefault(void* ptr, long long metric);
void* QDesignerActionEditorInterface_PaintEngine(void* ptr);
void* QDesignerActionEditorInterface_PaintEngineDefault(void* ptr);
void QDesignerContainerExtension_AddWidget(void* ptr, void* page);
char QDesignerContainerExtension_CanAddWidget(void* ptr);
char QDesignerContainerExtension_CanAddWidgetDefault(void* ptr);
@ -458,10 +464,16 @@ void QDesignerFormWindowInterface_DeleteLater(void* ptr);
void QDesignerFormWindowInterface_DeleteLaterDefault(void* ptr);
void QDesignerFormWindowInterface_DisconnectNotify(void* ptr, void* sign);
void QDesignerFormWindowInterface_DisconnectNotifyDefault(void* ptr, void* sign);
char QDesignerFormWindowInterface_Event(void* ptr, void* e);
char QDesignerFormWindowInterface_EventDefault(void* ptr, void* e);
char QDesignerFormWindowInterface_EventFilter(void* ptr, void* watched, void* event);
char QDesignerFormWindowInterface_EventFilterDefault(void* ptr, void* watched, void* event);
void* QDesignerFormWindowInterface_MetaObject(void* ptr);
void* QDesignerFormWindowInterface_MetaObjectDefault(void* ptr);
int QDesignerFormWindowInterface_Metric(void* ptr, long long metric);
int QDesignerFormWindowInterface_MetricDefault(void* ptr, long long metric);
void* QDesignerFormWindowInterface_PaintEngine(void* ptr);
void* QDesignerFormWindowInterface_PaintEngineDefault(void* ptr);
void* QDesignerFormWindowManagerInterface_Action(void* ptr, long long action);
void* QDesignerFormWindowManagerInterface_ActionGroup(void* ptr, long long actionGroup);
void* QDesignerFormWindowManagerInterface_ActiveFormWindow(void* ptr);
@ -648,10 +660,16 @@ void QDesignerObjectInspectorInterface_DeleteLater(void* ptr);
void QDesignerObjectInspectorInterface_DeleteLaterDefault(void* ptr);
void QDesignerObjectInspectorInterface_DisconnectNotify(void* ptr, void* sign);
void QDesignerObjectInspectorInterface_DisconnectNotifyDefault(void* ptr, void* sign);
char QDesignerObjectInspectorInterface_Event(void* ptr, void* e);
char QDesignerObjectInspectorInterface_EventDefault(void* ptr, void* e);
char QDesignerObjectInspectorInterface_EventFilter(void* ptr, void* watched, void* event);
char QDesignerObjectInspectorInterface_EventFilterDefault(void* ptr, void* watched, void* event);
void* QDesignerObjectInspectorInterface_MetaObject(void* ptr);
void* QDesignerObjectInspectorInterface_MetaObjectDefault(void* ptr);
int QDesignerObjectInspectorInterface_Metric(void* ptr, long long metric);
int QDesignerObjectInspectorInterface_MetricDefault(void* ptr, long long metric);
void* QDesignerObjectInspectorInterface_PaintEngine(void* ptr);
void* QDesignerObjectInspectorInterface_PaintEngineDefault(void* ptr);
void* QDesignerPropertyEditorInterface_NewQDesignerPropertyEditorInterface(void* parent, long long flags);
void* QDesignerPropertyEditorInterface_Core(void* ptr);
void* QDesignerPropertyEditorInterface_CoreDefault(void* ptr);
@ -784,10 +802,16 @@ void QDesignerPropertyEditorInterface_DeleteLater(void* ptr);
void QDesignerPropertyEditorInterface_DeleteLaterDefault(void* ptr);
void QDesignerPropertyEditorInterface_DisconnectNotify(void* ptr, void* sign);
void QDesignerPropertyEditorInterface_DisconnectNotifyDefault(void* ptr, void* sign);
char QDesignerPropertyEditorInterface_Event(void* ptr, void* e);
char QDesignerPropertyEditorInterface_EventDefault(void* ptr, void* e);
char QDesignerPropertyEditorInterface_EventFilter(void* ptr, void* watched, void* event);
char QDesignerPropertyEditorInterface_EventFilterDefault(void* ptr, void* watched, void* event);
void* QDesignerPropertyEditorInterface_MetaObject(void* ptr);
void* QDesignerPropertyEditorInterface_MetaObjectDefault(void* ptr);
int QDesignerPropertyEditorInterface_Metric(void* ptr, long long metric);
int QDesignerPropertyEditorInterface_MetricDefault(void* ptr, long long metric);
void* QDesignerPropertyEditorInterface_PaintEngine(void* ptr);
void* QDesignerPropertyEditorInterface_PaintEngineDefault(void* ptr);
int QDesignerPropertySheetExtension_Count(void* ptr);
char QDesignerPropertySheetExtension_HasReset(void* ptr, int index);
int QDesignerPropertySheetExtension_IndexOf(void* ptr, char* name);
@ -936,10 +960,16 @@ void QDesignerWidgetBoxInterface_DeleteLater(void* ptr);
void QDesignerWidgetBoxInterface_DeleteLaterDefault(void* ptr);
void QDesignerWidgetBoxInterface_DisconnectNotify(void* ptr, void* sign);
void QDesignerWidgetBoxInterface_DisconnectNotifyDefault(void* ptr, void* sign);
char QDesignerWidgetBoxInterface_Event(void* ptr, void* e);
char QDesignerWidgetBoxInterface_EventDefault(void* ptr, void* e);
char QDesignerWidgetBoxInterface_EventFilter(void* ptr, void* watched, void* event);
char QDesignerWidgetBoxInterface_EventFilterDefault(void* ptr, void* watched, void* event);
void* QDesignerWidgetBoxInterface_MetaObject(void* ptr);
void* QDesignerWidgetBoxInterface_MetaObjectDefault(void* ptr);
int QDesignerWidgetBoxInterface_Metric(void* ptr, long long metric);
int QDesignerWidgetBoxInterface_MetricDefault(void* ptr, long long metric);
void* QDesignerWidgetBoxInterface_PaintEngine(void* ptr);
void* QDesignerWidgetBoxInterface_PaintEngineDefault(void* ptr);
void* QExtensionFactory_NewQExtensionFactory(void* parent);
void* QExtensionFactory_CreateExtension(void* ptr, void* object, char* iid, void* parent);
void* QExtensionFactory_CreateExtensionDefault(void* ptr, void* object, char* iid, void* parent);

View file

@ -47,6 +47,8 @@
#include <QMouseEvent>
#include <QMoveEvent>
#include <QObject>
#include <QPaintDevice>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPainter>
#include <QPoint>
@ -676,13 +678,17 @@ public:
void showNormal() { callbackQHelpContentWidget_ShowNormal(this); };
void tabletEvent(QTabletEvent * event) { callbackQHelpContentWidget_TabletEvent(this, event); };
void updateMicroFocus() { callbackQHelpContentWidget_UpdateMicroFocus(this); };
void timerEvent(QTimerEvent * event) { callbackQHelpContentWidget_TimerEvent(this, event); };
void childEvent(QChildEvent * event) { callbackQHelpContentWidget_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQHelpContentWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQHelpContentWidget_CustomEvent(this, event); };
void deleteLater() { callbackQHelpContentWidget_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQHelpContentWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQHelpContentWidget_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQHelpContentWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQHelpContentWidget_MetaObject(const_cast<MyQHelpContentWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQHelpContentWidget_Metric(const_cast<MyQHelpContentWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQHelpContentWidget_PaintEngine(const_cast<MyQHelpContentWidget*>(this))); };
};
void* QHelpContentWidget_IndexOf(void* ptr, void* link)
@ -1757,6 +1763,16 @@ void QHelpContentWidget_UpdateMicroFocusDefault(void* ptr)
static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::updateMicroFocus();
}
void QHelpContentWidget_TimerEvent(void* ptr, void* event)
{
static_cast<QHelpContentWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}
void QHelpContentWidget_TimerEventDefault(void* ptr, void* event)
{
static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::timerEvent(static_cast<QTimerEvent*>(event));
}
void QHelpContentWidget_ChildEvent(void* ptr, void* event)
{
static_cast<QHelpContentWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
@ -1807,6 +1823,16 @@ void QHelpContentWidget_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QHelpContentWidget_Event(void* ptr, void* e)
{
return static_cast<QHelpContentWidget*>(ptr)->event(static_cast<QEvent*>(e));
}
char QHelpContentWidget_EventDefault(void* ptr, void* e)
{
return static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::event(static_cast<QEvent*>(e));
}
char QHelpContentWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QHelpContentWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -1827,6 +1853,26 @@ void* QHelpContentWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::metaObject());
}
int QHelpContentWidget_Metric(void* ptr, long long metric)
{
return static_cast<QHelpContentWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QHelpContentWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QHelpContentWidget_PaintEngine(void* ptr)
{
return static_cast<QHelpContentWidget*>(ptr)->paintEngine();
}
void* QHelpContentWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QHelpContentWidget*>(ptr)->QHelpContentWidget::paintEngine();
}
void* QHelpEngine_NewQHelpEngine(char* collectionFile, void* parent)
{
return new QHelpEngine(QString(collectionFile), static_cast<QObject*>(parent));
@ -2873,13 +2919,17 @@ public:
void showNormal() { callbackQHelpIndexWidget_ShowNormal(this); };
void tabletEvent(QTabletEvent * event) { callbackQHelpIndexWidget_TabletEvent(this, event); };
void updateMicroFocus() { callbackQHelpIndexWidget_UpdateMicroFocus(this); };
void timerEvent(QTimerEvent * event) { callbackQHelpIndexWidget_TimerEvent(this, event); };
void childEvent(QChildEvent * event) { callbackQHelpIndexWidget_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQHelpIndexWidget_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
void customEvent(QEvent * event) { callbackQHelpIndexWidget_CustomEvent(this, event); };
void deleteLater() { callbackQHelpIndexWidget_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQHelpIndexWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQHelpIndexWidget_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQHelpIndexWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQHelpIndexWidget_MetaObject(const_cast<MyQHelpIndexWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQHelpIndexWidget_Metric(const_cast<MyQHelpIndexWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQHelpIndexWidget_PaintEngine(const_cast<MyQHelpIndexWidget*>(this))); };
};
void QHelpIndexWidget_ActivateCurrentItem(void* ptr)
@ -3819,6 +3869,16 @@ void QHelpIndexWidget_UpdateMicroFocusDefault(void* ptr)
static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::updateMicroFocus();
}
void QHelpIndexWidget_TimerEvent(void* ptr, void* event)
{
static_cast<QHelpIndexWidget*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
}
void QHelpIndexWidget_TimerEventDefault(void* ptr, void* event)
{
static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::timerEvent(static_cast<QTimerEvent*>(event));
}
void QHelpIndexWidget_ChildEvent(void* ptr, void* event)
{
static_cast<QHelpIndexWidget*>(ptr)->childEvent(static_cast<QChildEvent*>(event));
@ -3869,6 +3929,16 @@ void QHelpIndexWidget_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QHelpIndexWidget_Event(void* ptr, void* e)
{
return static_cast<QHelpIndexWidget*>(ptr)->event(static_cast<QEvent*>(e));
}
char QHelpIndexWidget_EventDefault(void* ptr, void* e)
{
return static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::event(static_cast<QEvent*>(e));
}
char QHelpIndexWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QHelpIndexWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -3889,6 +3959,26 @@ void* QHelpIndexWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::metaObject());
}
int QHelpIndexWidget_Metric(void* ptr, long long metric)
{
return static_cast<QHelpIndexWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QHelpIndexWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QHelpIndexWidget_PaintEngine(void* ptr)
{
return static_cast<QHelpIndexWidget*>(ptr)->paintEngine();
}
void* QHelpIndexWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QHelpIndexWidget*>(ptr)->QHelpIndexWidget::paintEngine();
}
class MyQHelpSearchEngine: public QHelpSearchEngine
{
public:
@ -4200,8 +4290,11 @@ public:
void customEvent(QEvent * event) { callbackQHelpSearchQueryWidget_CustomEvent(this, event); };
void deleteLater() { callbackQHelpSearchQueryWidget_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQHelpSearchQueryWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQHelpSearchQueryWidget_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQHelpSearchQueryWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQHelpSearchQueryWidget_MetaObject(const_cast<MyQHelpSearchQueryWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQHelpSearchQueryWidget_Metric(const_cast<MyQHelpSearchQueryWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQHelpSearchQueryWidget_PaintEngine(const_cast<MyQHelpSearchQueryWidget*>(this))); };
};
char QHelpSearchQueryWidget_IsCompactMode(void* ptr)
@ -4841,6 +4934,16 @@ void QHelpSearchQueryWidget_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QHelpSearchQueryWidget*>(ptr)->QHelpSearchQueryWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QHelpSearchQueryWidget_Event(void* ptr, void* e)
{
return static_cast<QHelpSearchQueryWidget*>(ptr)->event(static_cast<QEvent*>(e));
}
char QHelpSearchQueryWidget_EventDefault(void* ptr, void* e)
{
return static_cast<QHelpSearchQueryWidget*>(ptr)->QHelpSearchQueryWidget::event(static_cast<QEvent*>(e));
}
char QHelpSearchQueryWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QHelpSearchQueryWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -4861,6 +4964,26 @@ void* QHelpSearchQueryWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QHelpSearchQueryWidget*>(ptr)->QHelpSearchQueryWidget::metaObject());
}
int QHelpSearchQueryWidget_Metric(void* ptr, long long metric)
{
return static_cast<QHelpSearchQueryWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QHelpSearchQueryWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QHelpSearchQueryWidget*>(ptr)->QHelpSearchQueryWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QHelpSearchQueryWidget_PaintEngine(void* ptr)
{
return static_cast<QHelpSearchQueryWidget*>(ptr)->paintEngine();
}
void* QHelpSearchQueryWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QHelpSearchQueryWidget*>(ptr)->QHelpSearchQueryWidget::paintEngine();
}
class MyQHelpSearchResultWidget: public QHelpSearchResultWidget
{
public:
@ -4924,8 +5047,11 @@ public:
void customEvent(QEvent * event) { callbackQHelpSearchResultWidget_CustomEvent(this, event); };
void deleteLater() { callbackQHelpSearchResultWidget_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQHelpSearchResultWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQHelpSearchResultWidget_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQHelpSearchResultWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQHelpSearchResultWidget_MetaObject(const_cast<MyQHelpSearchResultWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQHelpSearchResultWidget_Metric(const_cast<MyQHelpSearchResultWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQHelpSearchResultWidget_PaintEngine(const_cast<MyQHelpSearchResultWidget*>(this))); };
};
void* QHelpSearchResultWidget_LinkAt(void* ptr, void* point)
@ -5545,6 +5671,16 @@ void QHelpSearchResultWidget_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QHelpSearchResultWidget*>(ptr)->QHelpSearchResultWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QHelpSearchResultWidget_Event(void* ptr, void* e)
{
return static_cast<QHelpSearchResultWidget*>(ptr)->event(static_cast<QEvent*>(e));
}
char QHelpSearchResultWidget_EventDefault(void* ptr, void* e)
{
return static_cast<QHelpSearchResultWidget*>(ptr)->QHelpSearchResultWidget::event(static_cast<QEvent*>(e));
}
char QHelpSearchResultWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QHelpSearchResultWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -5565,3 +5701,23 @@ void* QHelpSearchResultWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QHelpSearchResultWidget*>(ptr)->QHelpSearchResultWidget::metaObject());
}
int QHelpSearchResultWidget_Metric(void* ptr, long long metric)
{
return static_cast<QHelpSearchResultWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QHelpSearchResultWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QHelpSearchResultWidget*>(ptr)->QHelpSearchResultWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QHelpSearchResultWidget_PaintEngine(void* ptr)
{
return static_cast<QHelpSearchResultWidget*>(ptr)->paintEngine();
}
void* QHelpSearchResultWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QHelpSearchResultWidget*>(ptr)->QHelpSearchResultWidget::paintEngine();
}

View file

@ -5489,6 +5489,42 @@ func (ptr *QHelpContentWidget) UpdateMicroFocusDefault() {
}
}
//export callbackQHelpContentWidget_TimerEvent
func callbackQHelpContentWidget_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpContentWidget::timerEvent"); signal != nil {
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
} else {
NewQHelpContentWidgetFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
}
}
func (ptr *QHelpContentWidget) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::timerEvent", f)
}
}
func (ptr *QHelpContentWidget) DisconnectTimerEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::timerEvent")
}
}
func (ptr *QHelpContentWidget) TimerEvent(event core.QTimerEvent_ITF) {
if ptr.Pointer() != nil {
C.QHelpContentWidget_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
}
}
func (ptr *QHelpContentWidget) TimerEventDefault(event core.QTimerEvent_ITF) {
if ptr.Pointer() != nil {
C.QHelpContentWidget_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
}
}
//export callbackQHelpContentWidget_ChildEvent
func callbackQHelpContentWidget_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
@ -5672,6 +5708,44 @@ func (ptr *QHelpContentWidget) DisconnectNotifyDefault(sign core.QMetaMethod_ITF
}
}
//export callbackQHelpContentWidget_Event
func callbackQHelpContentWidget_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpContentWidget::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQHelpContentWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QHelpContentWidget) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::event", f)
}
}
func (ptr *QHelpContentWidget) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::event")
}
}
func (ptr *QHelpContentWidget) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpContentWidget_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QHelpContentWidget) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpContentWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQHelpContentWidget_EventFilter
func callbackQHelpContentWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -5748,6 +5822,82 @@ func (ptr *QHelpContentWidget) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQHelpContentWidget_Metric
func callbackQHelpContentWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpContentWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQHelpContentWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QHelpContentWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::metric", f)
}
}
func (ptr *QHelpContentWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::metric")
}
}
func (ptr *QHelpContentWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpContentWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QHelpContentWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpContentWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQHelpContentWidget_PaintEngine
func callbackQHelpContentWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpContentWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQHelpContentWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QHelpContentWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::paintEngine", f)
}
}
func (ptr *QHelpContentWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpContentWidget::paintEngine")
}
}
func (ptr *QHelpContentWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpContentWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QHelpContentWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpContentWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QHelpEngine struct {
QHelpEngineCore
}
@ -12113,6 +12263,42 @@ func (ptr *QHelpIndexWidget) UpdateMicroFocusDefault() {
}
}
//export callbackQHelpIndexWidget_TimerEvent
func callbackQHelpIndexWidget_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpIndexWidget::timerEvent"); signal != nil {
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
} else {
NewQHelpIndexWidgetFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
}
}
func (ptr *QHelpIndexWidget) ConnectTimerEvent(f func(event *core.QTimerEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::timerEvent", f)
}
}
func (ptr *QHelpIndexWidget) DisconnectTimerEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::timerEvent")
}
}
func (ptr *QHelpIndexWidget) TimerEvent(event core.QTimerEvent_ITF) {
if ptr.Pointer() != nil {
C.QHelpIndexWidget_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
}
}
func (ptr *QHelpIndexWidget) TimerEventDefault(event core.QTimerEvent_ITF) {
if ptr.Pointer() != nil {
C.QHelpIndexWidget_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
}
}
//export callbackQHelpIndexWidget_ChildEvent
func callbackQHelpIndexWidget_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
@ -12296,6 +12482,44 @@ func (ptr *QHelpIndexWidget) DisconnectNotifyDefault(sign core.QMetaMethod_ITF)
}
}
//export callbackQHelpIndexWidget_Event
func callbackQHelpIndexWidget_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpIndexWidget::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQHelpIndexWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QHelpIndexWidget) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::event", f)
}
}
func (ptr *QHelpIndexWidget) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::event")
}
}
func (ptr *QHelpIndexWidget) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpIndexWidget_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QHelpIndexWidget) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpIndexWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQHelpIndexWidget_EventFilter
func callbackQHelpIndexWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -12372,6 +12596,82 @@ func (ptr *QHelpIndexWidget) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQHelpIndexWidget_Metric
func callbackQHelpIndexWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpIndexWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQHelpIndexWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QHelpIndexWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::metric", f)
}
}
func (ptr *QHelpIndexWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::metric")
}
}
func (ptr *QHelpIndexWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpIndexWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QHelpIndexWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpIndexWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQHelpIndexWidget_PaintEngine
func callbackQHelpIndexWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpIndexWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQHelpIndexWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QHelpIndexWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::paintEngine", f)
}
}
func (ptr *QHelpIndexWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpIndexWidget::paintEngine")
}
}
func (ptr *QHelpIndexWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpIndexWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QHelpIndexWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpIndexWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QHelpSearchEngine struct {
core.QObject
}
@ -15348,6 +15648,44 @@ func (ptr *QHelpSearchQueryWidget) DisconnectNotifyDefault(sign core.QMetaMethod
}
}
//export callbackQHelpSearchQueryWidget_Event
func callbackQHelpSearchQueryWidget_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpSearchQueryWidget::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQHelpSearchQueryWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QHelpSearchQueryWidget) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchQueryWidget::event", f)
}
}
func (ptr *QHelpSearchQueryWidget) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchQueryWidget::event")
}
}
func (ptr *QHelpSearchQueryWidget) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpSearchQueryWidget_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QHelpSearchQueryWidget) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpSearchQueryWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQHelpSearchQueryWidget_EventFilter
func callbackQHelpSearchQueryWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -15424,6 +15762,82 @@ func (ptr *QHelpSearchQueryWidget) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQHelpSearchQueryWidget_Metric
func callbackQHelpSearchQueryWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpSearchQueryWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQHelpSearchQueryWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QHelpSearchQueryWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchQueryWidget::metric", f)
}
}
func (ptr *QHelpSearchQueryWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchQueryWidget::metric")
}
}
func (ptr *QHelpSearchQueryWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpSearchQueryWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QHelpSearchQueryWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpSearchQueryWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQHelpSearchQueryWidget_PaintEngine
func callbackQHelpSearchQueryWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpSearchQueryWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQHelpSearchQueryWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QHelpSearchQueryWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchQueryWidget::paintEngine", f)
}
}
func (ptr *QHelpSearchQueryWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchQueryWidget::paintEngine")
}
}
func (ptr *QHelpSearchQueryWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpSearchQueryWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QHelpSearchQueryWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpSearchQueryWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QHelpSearchResultWidget struct {
widgets.QWidget
}
@ -17651,6 +18065,44 @@ func (ptr *QHelpSearchResultWidget) DisconnectNotifyDefault(sign core.QMetaMetho
}
}
//export callbackQHelpSearchResultWidget_Event
func callbackQHelpSearchResultWidget_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpSearchResultWidget::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQHelpSearchResultWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QHelpSearchResultWidget) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchResultWidget::event", f)
}
}
func (ptr *QHelpSearchResultWidget) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchResultWidget::event")
}
}
func (ptr *QHelpSearchResultWidget) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpSearchResultWidget_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QHelpSearchResultWidget) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QHelpSearchResultWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQHelpSearchResultWidget_EventFilter
func callbackQHelpSearchResultWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -17726,3 +18178,79 @@ func (ptr *QHelpSearchResultWidget) MetaObjectDefault() *core.QMetaObject {
}
return nil
}
//export callbackQHelpSearchResultWidget_Metric
func callbackQHelpSearchResultWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpSearchResultWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQHelpSearchResultWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QHelpSearchResultWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchResultWidget::metric", f)
}
}
func (ptr *QHelpSearchResultWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchResultWidget::metric")
}
}
func (ptr *QHelpSearchResultWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpSearchResultWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QHelpSearchResultWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QHelpSearchResultWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQHelpSearchResultWidget_PaintEngine
func callbackQHelpSearchResultWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QHelpSearchResultWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQHelpSearchResultWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QHelpSearchResultWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchResultWidget::paintEngine", f)
}
}
func (ptr *QHelpSearchResultWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QHelpSearchResultWidget::paintEngine")
}
}
func (ptr *QHelpSearchResultWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpSearchResultWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QHelpSearchResultWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QHelpSearchResultWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}

View file

@ -318,6 +318,8 @@ void QHelpContentWidget_TabletEvent(void* ptr, void* event);
void QHelpContentWidget_TabletEventDefault(void* ptr, void* event);
void QHelpContentWidget_UpdateMicroFocus(void* ptr);
void QHelpContentWidget_UpdateMicroFocusDefault(void* ptr);
void QHelpContentWidget_TimerEvent(void* ptr, void* event);
void QHelpContentWidget_TimerEventDefault(void* ptr, void* event);
void QHelpContentWidget_ChildEvent(void* ptr, void* event);
void QHelpContentWidget_ChildEventDefault(void* ptr, void* event);
void QHelpContentWidget_ConnectNotify(void* ptr, void* sign);
@ -328,10 +330,16 @@ void QHelpContentWidget_DeleteLater(void* ptr);
void QHelpContentWidget_DeleteLaterDefault(void* ptr);
void QHelpContentWidget_DisconnectNotify(void* ptr, void* sign);
void QHelpContentWidget_DisconnectNotifyDefault(void* ptr, void* sign);
char QHelpContentWidget_Event(void* ptr, void* e);
char QHelpContentWidget_EventDefault(void* ptr, void* e);
char QHelpContentWidget_EventFilter(void* ptr, void* watched, void* event);
char QHelpContentWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QHelpContentWidget_MetaObject(void* ptr);
void* QHelpContentWidget_MetaObjectDefault(void* ptr);
int QHelpContentWidget_Metric(void* ptr, long long metric);
int QHelpContentWidget_MetricDefault(void* ptr, long long metric);
void* QHelpContentWidget_PaintEngine(void* ptr);
void* QHelpContentWidget_PaintEngineDefault(void* ptr);
void* QHelpEngine_NewQHelpEngine(char* collectionFile, void* parent);
void* QHelpEngine_ContentModel(void* ptr);
void* QHelpEngine_ContentWidget(void* ptr);
@ -695,6 +703,8 @@ void QHelpIndexWidget_TabletEvent(void* ptr, void* event);
void QHelpIndexWidget_TabletEventDefault(void* ptr, void* event);
void QHelpIndexWidget_UpdateMicroFocus(void* ptr);
void QHelpIndexWidget_UpdateMicroFocusDefault(void* ptr);
void QHelpIndexWidget_TimerEvent(void* ptr, void* event);
void QHelpIndexWidget_TimerEventDefault(void* ptr, void* event);
void QHelpIndexWidget_ChildEvent(void* ptr, void* event);
void QHelpIndexWidget_ChildEventDefault(void* ptr, void* event);
void QHelpIndexWidget_ConnectNotify(void* ptr, void* sign);
@ -705,10 +715,16 @@ void QHelpIndexWidget_DeleteLater(void* ptr);
void QHelpIndexWidget_DeleteLaterDefault(void* ptr);
void QHelpIndexWidget_DisconnectNotify(void* ptr, void* sign);
void QHelpIndexWidget_DisconnectNotifyDefault(void* ptr, void* sign);
char QHelpIndexWidget_Event(void* ptr, void* e);
char QHelpIndexWidget_EventDefault(void* ptr, void* e);
char QHelpIndexWidget_EventFilter(void* ptr, void* watched, void* event);
char QHelpIndexWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QHelpIndexWidget_MetaObject(void* ptr);
void* QHelpIndexWidget_MetaObjectDefault(void* ptr);
int QHelpIndexWidget_Metric(void* ptr, long long metric);
int QHelpIndexWidget_MetricDefault(void* ptr, long long metric);
void* QHelpIndexWidget_PaintEngine(void* ptr);
void* QHelpIndexWidget_PaintEngineDefault(void* ptr);
void* QHelpSearchEngine_NewQHelpSearchEngine(void* helpEngine, void* parent);
void QHelpSearchEngine_CancelIndexing(void* ptr);
void QHelpSearchEngine_CancelSearching(void* ptr);
@ -881,10 +897,16 @@ void QHelpSearchQueryWidget_DeleteLater(void* ptr);
void QHelpSearchQueryWidget_DeleteLaterDefault(void* ptr);
void QHelpSearchQueryWidget_DisconnectNotify(void* ptr, void* sign);
void QHelpSearchQueryWidget_DisconnectNotifyDefault(void* ptr, void* sign);
char QHelpSearchQueryWidget_Event(void* ptr, void* e);
char QHelpSearchQueryWidget_EventDefault(void* ptr, void* e);
char QHelpSearchQueryWidget_EventFilter(void* ptr, void* watched, void* event);
char QHelpSearchQueryWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QHelpSearchQueryWidget_MetaObject(void* ptr);
void* QHelpSearchQueryWidget_MetaObjectDefault(void* ptr);
int QHelpSearchQueryWidget_Metric(void* ptr, long long metric);
int QHelpSearchQueryWidget_MetricDefault(void* ptr, long long metric);
void* QHelpSearchQueryWidget_PaintEngine(void* ptr);
void* QHelpSearchQueryWidget_PaintEngineDefault(void* ptr);
void* QHelpSearchResultWidget_LinkAt(void* ptr, void* point);
void QHelpSearchResultWidget_ConnectRequestShowLink(void* ptr);
void QHelpSearchResultWidget_DisconnectRequestShowLink(void* ptr);
@ -1008,10 +1030,16 @@ void QHelpSearchResultWidget_DeleteLater(void* ptr);
void QHelpSearchResultWidget_DeleteLaterDefault(void* ptr);
void QHelpSearchResultWidget_DisconnectNotify(void* ptr, void* sign);
void QHelpSearchResultWidget_DisconnectNotifyDefault(void* ptr, void* sign);
char QHelpSearchResultWidget_Event(void* ptr, void* e);
char QHelpSearchResultWidget_EventDefault(void* ptr, void* e);
char QHelpSearchResultWidget_EventFilter(void* ptr, void* watched, void* event);
char QHelpSearchResultWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QHelpSearchResultWidget_MetaObject(void* ptr);
void* QHelpSearchResultWidget_MetaObjectDefault(void* ptr);
int QHelpSearchResultWidget_Metric(void* ptr, long long metric);
int QHelpSearchResultWidget_MetricDefault(void* ptr, long long metric);
void* QHelpSearchResultWidget_PaintEngine(void* ptr);
void* QHelpSearchResultWidget_PaintEngineDefault(void* ptr);
#ifdef __cplusplus
}

View file

@ -14,12 +14,21 @@ func (c *Class) remove() {
func (c *Class) removeFunctions() {
for i := len(c.Functions) - 1; i >= 0; i-- {
if f := c.Functions[i]; (f.Status == "obsolete" || f.Status == "compat") ||
f := c.Functions[i]
switch {
case (f.Status == "obsolete" || f.Status == "compat") ||
!(f.Access == "public" || f.Access == "protected") ||
strings.ContainsAny(f.Name, "&<>=/!()[]{}^|*+-") ||
strings.Contains(f.Name, "Operator") {
strings.Contains(f.Name, "Operator"):
{
c.Functions = append(c.Functions[:i], c.Functions[i+1:]...)
}
c.Functions = append(c.Functions[:i], c.Functions[i+1:]...)
case (f.Virtual == IMPURE || f.Virtual == PURE) && f.Meta == CONSTRUCTOR:
{
c.Functions = append(c.Functions[:i], c.Functions[i+1:]...)
}
}
}
}

View file

@ -253,7 +253,7 @@ var Build = map[string]bool{
"Sailfish": false,
}
func isGeneric(f *parser.Function) bool {
func isJNIGeneric(f *parser.Function) bool {
if f.ClassName() == "QAndroidJniObject" {
switch f.Name {
@ -338,3 +338,32 @@ func classNeedsDestructor(c *parser.Class) bool {
func UseStub() bool {
return utils.QT_STUB() && !parser.CurrentState.Minimal && !parser.CurrentState.Moc && !(parser.CurrentState.CurrentModule == "AndroidExtras" || parser.CurrentState.CurrentModule == "Sailfish")
}
func buildTags(module string) string {
switch {
case parser.CurrentState.Minimal:
{
return "// +build minimal"
}
case module == parser.MOC:
{
return ""
}
case module == "QtAndroidExtras":
{
return "// +build android"
}
case module == "QtSailfish":
{
return "// +build sailfish sailfish_emulator"
}
default:
{
return "// +build !minimal"
}
}
}

View file

@ -3,108 +3,122 @@ package templater
import (
"bytes"
"fmt"
"strings"
"github.com/therecipe/qt/internal/binding/converter"
"github.com/therecipe/qt/internal/binding/parser"
)
func test(bb *bytes.Buffer, class *parser.Class, fu func(*parser.Function) string, del string) {
func cTemplate(bb *bytes.Buffer, c *parser.Class, ef func(*parser.Enum, *parser.Value) string, ff func(*parser.Function) string, del string) {
cTemplateEnums(bb, c, ef, del)
if classIsSupported(c) {
cTemplateFunctions(bb, c, ff, del)
}
}
func cTemplateEnums(bb *bytes.Buffer, c *parser.Class, ef func(*parser.Enum, *parser.Value) string, del string) {
for _, enum := range c.Enums {
for _, value := range enum.Values {
if converter.EnumNeedsCppGlue(value.Value) {
fmt.Fprintf(bb, "%v%v", ef(enum, value), del)
}
}
}
}
func cTemplateFunctions(bb *bytes.Buffer, c *parser.Class, ff func(*parser.Function) string, del string) {
//TODO: put enum loop here
var implementedVirtuals = make(map[string]struct{})
//all class fs
for _, f := range class.Functions {
if !functionIsSupported(class, f) {
for _, f := range c.Functions {
if !functionIsSupported(c, f) {
continue
}
implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)] = struct{}{}
switch {
case f.Meta == parser.SIGNAL:
{
for _, signalMode := range []string{parser.CONNECT, parser.DISCONNECT} {
for _, m := range []string{parser.CONNECT, parser.DISCONNECT} {
var f = *f
f.SignalMode = signalMode
fmt.Fprintf(bb, "%v%v", fu(&f), del)
f.SignalMode = m
fmt.Fprintf(bb, "%v%v", ff(&f), del)
}
var f = *f
f.Meta = parser.PLAIN
if converter.IsPrivateSignal(&f) {
continue
if !converter.IsPrivateSignal(f) {
var f = *f
f.Meta = parser.PLAIN
fmt.Fprintf(bb, "%v%v", ff(&f), del)
}
fmt.Fprintf(bb, "%v%v", fu(&f), del)
}
case (f.Virtual == parser.IMPURE || f.Virtual == parser.PURE) && !strings.Contains(f.Meta, "constructor"):
case (f.Virtual == parser.IMPURE || f.Virtual == parser.PURE):
{
var f = *f
if f.Meta != parser.SLOT {
f.Meta = parser.PLAIN
}
fmt.Fprintf(bb, "%v%v", ff(&f), del)
fmt.Fprintf(bb, "%v%v", fu(&f), del)
if f.Virtual == parser.IMPURE {
f.Meta = parser.PLAIN
f.Default = true
fmt.Fprintf(bb, "%v%v", fu(&f), del)
fmt.Fprintf(bb, "%v%v", ff(&f), del)
}
}
case isGeneric(f):
case isJNIGeneric(f):
{
for _, mode := range converter.CppOutputParametersJNIGenericModes(f) {
for _, m := range converter.CppOutputParametersJNIGenericModes(f) {
var f = *f
f.TemplateModeJNI = mode
fmt.Fprintf(bb, "%v%v", fu(&f), del)
f.TemplateModeJNI = m
fmt.Fprintf(bb, "%v%v", ff(&f), del)
}
}
default:
{
if !(f.Meta == parser.CONSTRUCTOR && hasUnimplementedPureVirtualFunctions(class.Name)) {
fmt.Fprintf(bb, "%v%v", fu(f), del)
if !(f.Meta == parser.CONSTRUCTOR && hasUnimplementedPureVirtualFunctions(c.Name)) {
fmt.Fprintf(bb, "%v%v", ff(f), del)
}
}
}
}
//virtual parent functions
for _, parentClassName := range class.GetAllBases() {
var parentClass = parser.CurrentState.ClassMap[parentClassName]
if classIsSupported(parentClass) {
for _, bcn := range c.GetAllBases() {
var bc, exist = parser.CurrentState.ClassMap[bcn]
if !exist || !classIsSupported(bc) {
continue
}
for _, f := range parentClass.Functions {
if _, exists := implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)]; !exists {
implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)] = struct{}{}
if functionIsSupported(parentClass, f) {
if f.Meta != parser.SIGNAL && (f.Virtual == parser.IMPURE || f.Virtual == parser.PURE || f.Meta == parser.SLOT) && !strings.Contains(f.Meta, "structor") {
var f = *f
f.Fullname = fmt.Sprintf("%v::%v", class.Name, f.Name)
if f.Meta != parser.SLOT {
f.Meta = parser.PLAIN
}
fmt.Fprintf(bb, "%v%v", fu(&f), del)
var class, exist = f.Class()
if !exist || (class.Module == parser.MOC && f.Virtual == parser.PURE) {
continue
}
f.Meta = parser.PLAIN
f.Default = true
fmt.Fprintf(bb, "%v%v", fu(&f), del)
}
}
}
for _, f := range bc.Functions {
var _, exists = implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)]
if exists || !functionIsSupported(bc, f) {
continue
}
//TODO: signals and slots may not be needed
if f.Meta != parser.SIGNAL && (f.Virtual == parser.IMPURE || f.Virtual == parser.PURE || f.Meta == parser.SLOT) && f.Meta != parser.DESTRUCTOR {
implementedVirtuals[fmt.Sprint(f.Name, f.OverloadNumber)] = struct{}{}
var f = *f
f.Fullname = fmt.Sprintf("%v::%v", c.Name, f.Name)
if f.Meta != parser.SLOT {
f.Meta = parser.PLAIN
}
fmt.Fprintf(bb, "%v%v", ff(&f), del)
var c, exist = f.Class()
if !exist || c.Module == parser.MOC && f.Virtual == parser.PURE {
continue
}
f.Meta = parser.PLAIN
f.Default = true
fmt.Fprintf(bb, "%v%v", ff(&f), del)
}
}
}
}

View file

@ -6,7 +6,6 @@ import (
"sort"
"strings"
"github.com/therecipe/qt/internal/binding/converter"
"github.com/therecipe/qt/internal/binding/parser"
)
@ -14,52 +13,9 @@ func CppTemplate(module string) []byte {
var bb = new(bytes.Buffer)
defer bb.Reset()
var tmpArray = getSortedClassNamesForModule(module)
if module == parser.MOC {
var items = make(map[string]string)
for _, class := range tmpArray {
items[class] = parser.CurrentState.ClassMap[class].Bases
}
var provided = make([]string, 0)
for len(items) > 0 {
for item, dependency := range items {
var existsInOtherModule bool
if parser.CurrentState.ClassMap[dependency].Module != parser.MOC {
existsInOtherModule = true
}
var existsInCurrentOrder bool
for _, providedItem := range provided {
if dependency == providedItem {
existsInCurrentOrder = true
break
}
}
if existsInOtherModule || existsInCurrentOrder {
provided = append(provided, item)
delete(items, item)
}
}
}
tmpArray = provided
}
for _, className := range tmpArray {
for _, className := range getSortedClassNamesForModule(module) {
var class = parser.CurrentState.ClassMap[className]
//all class enums
for _, enum := range class.Enums {
for _, value := range enum.Values {
if converter.EnumNeedsCppGlue(value.Value) {
fmt.Fprintf(bb, "%v\n\n", cppEnum(enum, value))
}
}
}
if classIsSupported(class) {
var implementedVirtuals = make(map[string]struct{})
@ -138,7 +94,7 @@ func CppTemplate(module string) []byte {
//all class functions
for _, function := range class.Functions {
implementedVirtuals[fmt.Sprint(function.Fullname, function.OverloadNumber)] = struct{}{}
if functionIsSupported(class, function) && !strings.Contains(function.Meta, "constructor") {
if functionIsSupported(class, function) {
if function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SIGNAL || function.Meta == parser.SLOT {
if !(module == parser.MOC && function.Meta == parser.SLOT) {
fmt.Fprintf(bb, "\t%v\n", cppFunctionCallback(function))
@ -154,12 +110,12 @@ func CppTemplate(module string) []byte {
for _, function := range parentClass.Functions {
if _, exists := implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)]; !exists {
implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)] = struct{}{}
if functionIsSupported(class, function) && !strings.Contains(function.Meta, "structor") {
if functionIsSupported(class, function) && function.Meta != parser.DESTRUCTOR {
var function = *function
function.Fullname = fmt.Sprintf("%v::%v", class.Name, function.Name)
if function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SLOT {
implementedVirtuals[fmt.Sprint(fmt.Sprintf("%v::%v", class.Name, function.Name), function.OverloadNumber)] = struct{}{}
fmt.Fprintf(bb, "\t%v\n", cppFunctionCallback(&function))
}
@ -193,11 +149,10 @@ func CppTemplate(module string) []byte {
if class.Module == parser.MOC {
fmt.Fprintf(bb, "Q_DECLARE_METATYPE(%v*)\n\n", class.Name)
}
test(bb, class, cppFunction, "\n\n")
}
cTemplate(bb, class, cppEnum, cppFunction, "\n\n")
}
return preambleCpp(module, bb.Bytes())
@ -216,34 +171,7 @@ func preambleCpp(module string, input []byte) []byte {
#include "_cgo_export.h"
`,
func() string {
switch {
case parser.CurrentState.Minimal:
{
return "// +build minimal"
}
case module == parser.MOC:
{
return ""
}
case module == "QtAndroidExtras":
{
return "// +build android"
}
case module == "QtSailfish":
{
return "// +build sailfish sailfish_emulator"
}
default:
{
return "// +build !minimal"
}
}
}(),
buildTags(module),
func() string {
switch module {

View file

@ -150,12 +150,12 @@ ptr.SetPointer(nil)
//all class functions
for _, function := range class.Functions {
implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = struct{}{}
if functionIsSupported(class, function) {
implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = struct{}{}
switch {
case (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SIGNAL || function.Meta == parser.SLOT) && !strings.Contains(function.Meta, "constructor"):
case (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SIGNAL || function.Meta == parser.SLOT):
{
for _, signalMode := range []string{parser.CALLBACK, parser.CONNECT, parser.DISCONNECT} {
var function = *function
@ -185,7 +185,7 @@ ptr.SetPointer(nil)
}
}
case isGeneric(function):
case isJNIGeneric(function):
{
for _, mode := range converter.CppOutputParametersJNIGenericModes(function) {
var function = *function
@ -223,10 +223,10 @@ ptr.SetPointer(nil)
for _, function := range parentClass.Functions {
if _, exists := implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)]; !exists {
implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = struct{}{}
if functionIsSupported(parentClass, function) {
if function.Meta != parser.SIGNAL && (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SLOT) && !strings.Contains(function.Meta, "structor") {
if function.Meta != parser.SIGNAL && (function.Virtual == parser.IMPURE || function.Virtual == parser.PURE || function.Meta == parser.SLOT) && function.Meta != parser.DESTRUCTOR {
implementedVirtuals[fmt.Sprint(function.Name, function.OverloadNumber)] = struct{}{}
for _, signalMode := range []string{parser.CALLBACK, parser.CONNECT, parser.DISCONNECT} {
var pbf = function.Virtual == parser.PURE

View file

@ -5,7 +5,6 @@ import (
"fmt"
"strings"
"github.com/therecipe/qt/internal/binding/converter"
"github.com/therecipe/qt/internal/binding/parser"
)
@ -23,64 +22,43 @@ func HTemplate(module string) []byte {
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
%vextern "C" {
#endif
`,
func() string {
switch {
case parser.CurrentState.Minimal:
{
return "// +build minimal"
}
case module == parser.MOC:
{
return ""
}
case module == "QtAndroidExtras":
{
return "// +build android"
}
case module == "QtSailfish":
{
return "// +build sailfish sailfish_emulator"
}
default:
{
return "// +build !minimal"
}
}
}(),
buildTags(module),
strings.ToUpper(module),
strings.ToUpper(module))
strings.ToUpper(module),
func() string {
if module != parser.MOC {
return ""
}
var bb = new(bytes.Buffer)
defer bb.Reset()
for _, c := range parser.CurrentState.ClassMap {
if c.Module == parser.MOC {
fmt.Fprintf(bb, "class %v;\n", c.Name)
}
}
return bb.String()
}(),
)
fmt.Fprintf(bb, "struct %v_PackedString { char* data; long long len; };\n", strings.Title(module))
fmt.Fprintf(bb, "struct %v_PackedList { void* data; long long len; };\n", strings.Title(module))
//
for _, class := range getSortedClassesForModule(module) {
//all class enums
for _, enum := range class.Enums {
for _, value := range enum.Values {
if converter.EnumNeedsCppGlue(value.Value) {
fmt.Fprintf(bb, "%v;\n", cppEnumHeader(enum, value))
}
}
}
if classIsSupported(class) {
test(bb, class, cppFunctionHeader, ";\n")
}
cTemplate(bb, class, cppEnumHeader, cppFunctionHeader, ";\n")
}
//
fmt.Fprint(bb, `
#ifdef __cplusplus
}

View file

@ -18,7 +18,7 @@ type HelloClientRPC struct {
}
type HelloClientFactory struct {
HelloClientRPC //TODO: only needed until a bug is fixed (should be core.QObject)
core.QObject
_ func(addr string) *HelloClientRPC `slot:"newClient"`
}

View file

@ -17,7 +17,7 @@ type HelloClientRPC struct {
}
type HelloClientFactory struct {
HelloClientRPC //TODO: only needed until a bug is fixed (should be core.QObject)
core.QObject
_ func(msg string) `signal:"info"`
_ func(err, msg string) `signal:"error"`

View file

@ -114,6 +114,8 @@
#include <QNetworkConfiguration>
#include <QNetworkRequest>
#include <QObject>
#include <QPaintDevice>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
@ -6968,13 +6970,18 @@ public:
void enterEvent(QEvent * event) { callbackQCameraViewfinder_EnterEvent(this, event); };
void focusInEvent(QFocusEvent * event) { callbackQCameraViewfinder_FocusInEvent(this, event); };
void focusOutEvent(QFocusEvent * event) { callbackQCameraViewfinder_FocusOutEvent(this, event); };
void hideEvent(QHideEvent * event) { callbackQCameraViewfinder_HideEvent(this, event); };
void leaveEvent(QEvent * event) { callbackQCameraViewfinder_LeaveEvent(this, event); };
QSize minimumSizeHint() const { return *static_cast<QSize*>(callbackQCameraViewfinder_MinimumSizeHint(const_cast<MyQCameraViewfinder*>(this))); };
void moveEvent(QMoveEvent * event) { callbackQCameraViewfinder_MoveEvent(this, event); };
void paintEvent(QPaintEvent * event) { callbackQCameraViewfinder_PaintEvent(this, event); };
void setEnabled(bool vbo) { callbackQCameraViewfinder_SetEnabled(this, vbo); };
void setStyleSheet(const QString & styleSheet) { QByteArray t728ae7 = styleSheet.toUtf8(); QtMultimedia_PackedString styleSheetPacked = { const_cast<char*>(t728ae7.prepend("WHITESPACE").constData()+10), t728ae7.size()-10 };callbackQCameraViewfinder_SetStyleSheet(this, styleSheetPacked); };
void setVisible(bool visible) { callbackQCameraViewfinder_SetVisible(this, visible); };
void setWindowModified(bool vbo) { callbackQCameraViewfinder_SetWindowModified(this, vbo); };
void setWindowTitle(const QString & vqs) { QByteArray tda39a3 = vqs.toUtf8(); QtMultimedia_PackedString vqsPacked = { const_cast<char*>(tda39a3.prepend("WHITESPACE").constData()+10), tda39a3.size()-10 };callbackQCameraViewfinder_SetWindowTitle(this, vqsPacked); };
void showEvent(QShowEvent * event) { callbackQCameraViewfinder_ShowEvent(this, event); };
QSize sizeHint() const { return *static_cast<QSize*>(callbackQCameraViewfinder_SizeHint(const_cast<MyQCameraViewfinder*>(this))); };
void changeEvent(QEvent * event) { callbackQCameraViewfinder_ChangeEvent(this, event); };
bool close() { return callbackQCameraViewfinder_Close(this) != 0; };
void closeEvent(QCloseEvent * event) { callbackQCameraViewfinder_CloseEvent(this, event); };
@ -6995,6 +7002,7 @@ public:
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQCameraViewfinder_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, *result) != 0; };
void raise() { callbackQCameraViewfinder_Raise(this); };
void repaint() { callbackQCameraViewfinder_Repaint(this); };
void resizeEvent(QResizeEvent * event) { callbackQCameraViewfinder_ResizeEvent(this, event); };
void setDisabled(bool disable) { callbackQCameraViewfinder_SetDisabled(this, disable); };
void setFocus() { callbackQCameraViewfinder_SetFocus2(this); };
void setHidden(bool hidden) { callbackQCameraViewfinder_SetHidden(this, hidden); };
@ -7013,8 +7021,11 @@ public:
void customEvent(QEvent * event) { callbackQCameraViewfinder_CustomEvent(this, event); };
void deleteLater() { callbackQCameraViewfinder_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQCameraViewfinder_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQCameraViewfinder_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQCameraViewfinder_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQCameraViewfinder_MetaObject(const_cast<MyQCameraViewfinder*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQCameraViewfinder_Metric(const_cast<MyQCameraViewfinder*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQCameraViewfinder_PaintEngine(const_cast<MyQCameraViewfinder*>(this))); };
};
void* QCameraViewfinder_NewQCameraViewfinder(void* parent)
@ -7187,6 +7198,16 @@ void QCameraViewfinder_FocusOutEventDefault(void* ptr, void* event)
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::focusOutEvent(static_cast<QFocusEvent*>(event));
}
void QCameraViewfinder_HideEvent(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->hideEvent(static_cast<QHideEvent*>(event));
}
void QCameraViewfinder_HideEventDefault(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::hideEvent(static_cast<QHideEvent*>(event));
}
void QCameraViewfinder_LeaveEvent(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->leaveEvent(static_cast<QEvent*>(event));
@ -7207,6 +7228,26 @@ void* QCameraViewfinder_MinimumSizeHintDefault(void* ptr)
return ({ QSize tmpValue = static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::minimumSizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void QCameraViewfinder_MoveEvent(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->moveEvent(static_cast<QMoveEvent*>(event));
}
void QCameraViewfinder_MoveEventDefault(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::moveEvent(static_cast<QMoveEvent*>(event));
}
void QCameraViewfinder_PaintEvent(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->paintEvent(static_cast<QPaintEvent*>(event));
}
void QCameraViewfinder_PaintEventDefault(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::paintEvent(static_cast<QPaintEvent*>(event));
}
void QCameraViewfinder_SetEnabled(void* ptr, char vbo)
{
QMetaObject::invokeMethod(static_cast<QCameraViewfinder*>(ptr), "setEnabled", Q_ARG(bool, vbo != 0));
@ -7257,6 +7298,26 @@ void QCameraViewfinder_SetWindowTitleDefault(void* ptr, char* vqs)
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::setWindowTitle(QString(vqs));
}
void QCameraViewfinder_ShowEvent(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->showEvent(static_cast<QShowEvent*>(event));
}
void QCameraViewfinder_ShowEventDefault(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::showEvent(static_cast<QShowEvent*>(event));
}
void* QCameraViewfinder_SizeHint(void* ptr)
{
return ({ QSize tmpValue = static_cast<QCameraViewfinder*>(ptr)->sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void* QCameraViewfinder_SizeHintDefault(void* ptr)
{
return ({ QSize tmpValue = static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::sizeHint(); new QSize(tmpValue.width(), tmpValue.height()); });
}
void QCameraViewfinder_ChangeEvent(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->changeEvent(static_cast<QEvent*>(event));
@ -7459,6 +7520,16 @@ void QCameraViewfinder_RepaintDefault(void* ptr)
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::repaint();
}
void QCameraViewfinder_ResizeEvent(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(event));
}
void QCameraViewfinder_ResizeEventDefault(void* ptr, void* event)
{
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::resizeEvent(static_cast<QResizeEvent*>(event));
}
void QCameraViewfinder_SetDisabled(void* ptr, char disable)
{
QMetaObject::invokeMethod(static_cast<QCameraViewfinder*>(ptr), "setDisabled", Q_ARG(bool, disable != 0));
@ -7639,6 +7710,16 @@ void QCameraViewfinder_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QCameraViewfinder_Event(void* ptr, void* e)
{
return static_cast<QCameraViewfinder*>(ptr)->event(static_cast<QEvent*>(e));
}
char QCameraViewfinder_EventDefault(void* ptr, void* e)
{
return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::event(static_cast<QEvent*>(e));
}
char QCameraViewfinder_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QCameraViewfinder*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -7659,6 +7740,26 @@ void* QCameraViewfinder_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::metaObject());
}
int QCameraViewfinder_Metric(void* ptr, long long metric)
{
return static_cast<QCameraViewfinder*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QCameraViewfinder_MetricDefault(void* ptr, long long metric)
{
return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QCameraViewfinder_PaintEngine(void* ptr)
{
return static_cast<QCameraViewfinder*>(ptr)->paintEngine();
}
void* QCameraViewfinder_PaintEngineDefault(void* ptr)
{
return static_cast<QCameraViewfinder*>(ptr)->QCameraViewfinder::paintEngine();
}
void* QCameraViewfinderSettings_NewQCameraViewfinderSettings()
{
return new QCameraViewfinderSettings();
@ -8275,6 +8376,7 @@ public:
void customEvent(QEvent * event) { callbackQGraphicsVideoItem_CustomEvent(this, event); };
void deleteLater() { callbackQGraphicsVideoItem_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsVideoItem_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQGraphicsVideoItem_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsVideoItem_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsVideoItem_MetaObject(const_cast<MyQGraphicsVideoItem*>(this))); };
void advance(int phase) { callbackQGraphicsVideoItem_Advance(this, phase); };
@ -8460,6 +8562,16 @@ void QGraphicsVideoItem_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QGraphicsVideoItem_Event(void* ptr, void* e)
{
return static_cast<QGraphicsVideoItem*>(ptr)->event(static_cast<QEvent*>(e));
}
char QGraphicsVideoItem_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsVideoItem*>(ptr)->QGraphicsVideoItem::event(static_cast<QEvent*>(e));
}
char QGraphicsVideoItem_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsVideoItem*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -17141,6 +17253,8 @@ public:
void disconnectNotify(const QMetaMethod & sign) { callbackQVideoWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQVideoWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQVideoWidget_MetaObject(const_cast<MyQVideoWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQVideoWidget_Metric(const_cast<MyQVideoWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQVideoWidget_PaintEngine(const_cast<MyQVideoWidget*>(this))); };
bool setMediaObject(QMediaObject * object) { return callbackQVideoWidget_SetMediaObject(this, object) != 0; };
};
@ -17886,6 +18000,26 @@ void* QVideoWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QVideoWidget*>(ptr)->QVideoWidget::metaObject());
}
int QVideoWidget_Metric(void* ptr, long long metric)
{
return static_cast<QVideoWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QVideoWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QVideoWidget*>(ptr)->QVideoWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QVideoWidget_PaintEngine(void* ptr)
{
return static_cast<QVideoWidget*>(ptr)->paintEngine();
}
void* QVideoWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QVideoWidget*>(ptr)->QVideoWidget::paintEngine();
}
char QVideoWidget_SetMediaObject(void* ptr, void* object)
{
return static_cast<QVideoWidget*>(ptr)->setMediaObject(static_cast<QMediaObject*>(object));

View file

@ -146,6 +146,44 @@ func (ptr *QAbstractPlanarVideoBuffer) HandleDefault() *core.QVariant {
return nil
}
//export callbackQAbstractPlanarVideoBuffer_Map
func callbackQAbstractPlanarVideoBuffer_Map(ptr unsafe.Pointer, mode C.longlong, numBytes C.int, bytesPerLine C.int) *C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QAbstractPlanarVideoBuffer::map"); signal != nil {
return C.CString(signal.(func(QAbstractVideoBuffer__MapMode, int, int) string)(QAbstractVideoBuffer__MapMode(mode), int(int32(numBytes)), int(int32(bytesPerLine))))
}
return C.CString(NewQAbstractPlanarVideoBufferFromPointer(ptr).MapDefault(QAbstractVideoBuffer__MapMode(mode), int(int32(numBytes)), int(int32(bytesPerLine))))
}
func (ptr *QAbstractPlanarVideoBuffer) ConnectMap(f func(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPlanarVideoBuffer::map", f)
}
}
func (ptr *QAbstractPlanarVideoBuffer) DisconnectMap() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPlanarVideoBuffer::map")
}
}
func (ptr *QAbstractPlanarVideoBuffer) Map(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string {
if ptr.Pointer() != nil {
return cGoUnpackString(C.QAbstractPlanarVideoBuffer_Map(ptr.Pointer(), C.longlong(mode), C.int(int32(numBytes)), C.int(int32(bytesPerLine))))
}
return ""
}
func (ptr *QAbstractPlanarVideoBuffer) MapDefault(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string {
if ptr.Pointer() != nil {
return cGoUnpackString(C.QAbstractPlanarVideoBuffer_MapDefault(ptr.Pointer(), C.longlong(mode), C.int(int32(numBytes)), C.int(int32(bytesPerLine))))
}
return ""
}
//export callbackQAbstractPlanarVideoBuffer_MapMode
func callbackQAbstractPlanarVideoBuffer_MapMode(ptr unsafe.Pointer) C.longlong {
@ -21039,6 +21077,42 @@ func (ptr *QCameraViewfinder) FocusOutEventDefault(event gui.QFocusEvent_ITF) {
}
}
//export callbackQCameraViewfinder_HideEvent
func callbackQCameraViewfinder_HideEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::hideEvent"); signal != nil {
signal.(func(*gui.QHideEvent))(gui.NewQHideEventFromPointer(event))
} else {
NewQCameraViewfinderFromPointer(ptr).HideEventDefault(gui.NewQHideEventFromPointer(event))
}
}
func (ptr *QCameraViewfinder) ConnectHideEvent(f func(event *gui.QHideEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::hideEvent", f)
}
}
func (ptr *QCameraViewfinder) DisconnectHideEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::hideEvent")
}
}
func (ptr *QCameraViewfinder) HideEvent(event gui.QHideEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_HideEvent(ptr.Pointer(), gui.PointerFromQHideEvent(event))
}
}
func (ptr *QCameraViewfinder) HideEventDefault(event gui.QHideEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_HideEventDefault(ptr.Pointer(), gui.PointerFromQHideEvent(event))
}
}
//export callbackQCameraViewfinder_LeaveEvent
func callbackQCameraViewfinder_LeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
@ -21117,6 +21191,78 @@ func (ptr *QCameraViewfinder) MinimumSizeHintDefault() *core.QSize {
return nil
}
//export callbackQCameraViewfinder_MoveEvent
func callbackQCameraViewfinder_MoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::moveEvent"); signal != nil {
signal.(func(*gui.QMoveEvent))(gui.NewQMoveEventFromPointer(event))
} else {
NewQCameraViewfinderFromPointer(ptr).MoveEventDefault(gui.NewQMoveEventFromPointer(event))
}
}
func (ptr *QCameraViewfinder) ConnectMoveEvent(f func(event *gui.QMoveEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::moveEvent", f)
}
}
func (ptr *QCameraViewfinder) DisconnectMoveEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::moveEvent")
}
}
func (ptr *QCameraViewfinder) MoveEvent(event gui.QMoveEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_MoveEvent(ptr.Pointer(), gui.PointerFromQMoveEvent(event))
}
}
func (ptr *QCameraViewfinder) MoveEventDefault(event gui.QMoveEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_MoveEventDefault(ptr.Pointer(), gui.PointerFromQMoveEvent(event))
}
}
//export callbackQCameraViewfinder_PaintEvent
func callbackQCameraViewfinder_PaintEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::paintEvent"); signal != nil {
signal.(func(*gui.QPaintEvent))(gui.NewQPaintEventFromPointer(event))
} else {
NewQCameraViewfinderFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(event))
}
}
func (ptr *QCameraViewfinder) ConnectPaintEvent(f func(event *gui.QPaintEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::paintEvent", f)
}
}
func (ptr *QCameraViewfinder) DisconnectPaintEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::paintEvent")
}
}
func (ptr *QCameraViewfinder) PaintEvent(event gui.QPaintEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
}
}
func (ptr *QCameraViewfinder) PaintEventDefault(event gui.QPaintEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
}
}
//export callbackQCameraViewfinder_SetEnabled
func callbackQCameraViewfinder_SetEnabled(ptr unsafe.Pointer, vbo C.char) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::setEnabled"); signal != nil {
@ -21300,6 +21446,84 @@ func (ptr *QCameraViewfinder) SetWindowTitleDefault(vqs string) {
}
}
//export callbackQCameraViewfinder_ShowEvent
func callbackQCameraViewfinder_ShowEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::showEvent"); signal != nil {
signal.(func(*gui.QShowEvent))(gui.NewQShowEventFromPointer(event))
} else {
NewQCameraViewfinderFromPointer(ptr).ShowEventDefault(gui.NewQShowEventFromPointer(event))
}
}
func (ptr *QCameraViewfinder) ConnectShowEvent(f func(event *gui.QShowEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::showEvent", f)
}
}
func (ptr *QCameraViewfinder) DisconnectShowEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::showEvent")
}
}
func (ptr *QCameraViewfinder) ShowEvent(event gui.QShowEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_ShowEvent(ptr.Pointer(), gui.PointerFromQShowEvent(event))
}
}
func (ptr *QCameraViewfinder) ShowEventDefault(event gui.QShowEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_ShowEventDefault(ptr.Pointer(), gui.PointerFromQShowEvent(event))
}
}
//export callbackQCameraViewfinder_SizeHint
func callbackQCameraViewfinder_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::sizeHint"); signal != nil {
return core.PointerFromQSize(signal.(func() *core.QSize)())
}
return core.PointerFromQSize(NewQCameraViewfinderFromPointer(ptr).SizeHintDefault())
}
func (ptr *QCameraViewfinder) ConnectSizeHint(f func() *core.QSize) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::sizeHint", f)
}
}
func (ptr *QCameraViewfinder) DisconnectSizeHint() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::sizeHint")
}
}
func (ptr *QCameraViewfinder) SizeHint() *core.QSize {
if ptr.Pointer() != nil {
var tmpValue = core.NewQSizeFromPointer(C.QCameraViewfinder_SizeHint(ptr.Pointer()))
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
return tmpValue
}
return nil
}
func (ptr *QCameraViewfinder) SizeHintDefault() *core.QSize {
if ptr.Pointer() != nil {
var tmpValue = core.NewQSizeFromPointer(C.QCameraViewfinder_SizeHintDefault(ptr.Pointer()))
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
return tmpValue
}
return nil
}
//export callbackQCameraViewfinder_ChangeEvent
func callbackQCameraViewfinder_ChangeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
@ -22031,6 +22255,42 @@ func (ptr *QCameraViewfinder) RepaintDefault() {
}
}
//export callbackQCameraViewfinder_ResizeEvent
func callbackQCameraViewfinder_ResizeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::resizeEvent"); signal != nil {
signal.(func(*gui.QResizeEvent))(gui.NewQResizeEventFromPointer(event))
} else {
NewQCameraViewfinderFromPointer(ptr).ResizeEventDefault(gui.NewQResizeEventFromPointer(event))
}
}
func (ptr *QCameraViewfinder) ConnectResizeEvent(f func(event *gui.QResizeEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::resizeEvent", f)
}
}
func (ptr *QCameraViewfinder) DisconnectResizeEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::resizeEvent")
}
}
func (ptr *QCameraViewfinder) ResizeEvent(event gui.QResizeEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_ResizeEvent(ptr.Pointer(), gui.PointerFromQResizeEvent(event))
}
}
func (ptr *QCameraViewfinder) ResizeEventDefault(event gui.QResizeEvent_ITF) {
if ptr.Pointer() != nil {
C.QCameraViewfinder_ResizeEventDefault(ptr.Pointer(), gui.PointerFromQResizeEvent(event))
}
}
//export callbackQCameraViewfinder_SetDisabled
func callbackQCameraViewfinder_SetDisabled(ptr unsafe.Pointer, disable C.char) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::setDisabled"); signal != nil {
@ -22672,6 +22932,44 @@ func (ptr *QCameraViewfinder) DisconnectNotifyDefault(sign core.QMetaMethod_ITF)
}
}
//export callbackQCameraViewfinder_Event
func callbackQCameraViewfinder_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQCameraViewfinderFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QCameraViewfinder) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::event", f)
}
}
func (ptr *QCameraViewfinder) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::event")
}
}
func (ptr *QCameraViewfinder) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QCameraViewfinder_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QCameraViewfinder) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QCameraViewfinder_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQCameraViewfinder_EventFilter
func callbackQCameraViewfinder_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -22748,6 +23046,82 @@ func (ptr *QCameraViewfinder) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQCameraViewfinder_Metric
func callbackQCameraViewfinder_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQCameraViewfinderFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QCameraViewfinder) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::metric", f)
}
}
func (ptr *QCameraViewfinder) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::metric")
}
}
func (ptr *QCameraViewfinder) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QCameraViewfinder_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QCameraViewfinder) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QCameraViewfinder_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQCameraViewfinder_PaintEngine
func callbackQCameraViewfinder_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QCameraViewfinder::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQCameraViewfinderFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QCameraViewfinder) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::paintEngine", f)
}
}
func (ptr *QCameraViewfinder) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QCameraViewfinder::paintEngine")
}
}
func (ptr *QCameraViewfinder) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QCameraViewfinder_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QCameraViewfinder) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QCameraViewfinder_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QCameraViewfinderSettings struct {
ptr unsafe.Pointer
}
@ -25103,6 +25477,44 @@ func (ptr *QGraphicsVideoItem) DisconnectNotifyDefault(sign core.QMetaMethod_ITF
}
}
//export callbackQGraphicsVideoItem_Event
func callbackQGraphicsVideoItem_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QGraphicsVideoItem::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QGraphicsVideoItem) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QGraphicsVideoItem::event", f)
}
}
func (ptr *QGraphicsVideoItem) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QGraphicsVideoItem::event")
}
}
func (ptr *QGraphicsVideoItem) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QGraphicsVideoItem_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QGraphicsVideoItem) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QGraphicsVideoItem_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQGraphicsVideoItem_EventFilter
func callbackQGraphicsVideoItem_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -53254,6 +53666,82 @@ func (ptr *QVideoWidget) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQVideoWidget_Metric
func callbackQVideoWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QVideoWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQVideoWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QVideoWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QVideoWidget::metric", f)
}
}
func (ptr *QVideoWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QVideoWidget::metric")
}
}
func (ptr *QVideoWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QVideoWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QVideoWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QVideoWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQVideoWidget_PaintEngine
func callbackQVideoWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QVideoWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQVideoWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QVideoWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QVideoWidget::paintEngine", f)
}
}
func (ptr *QVideoWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QVideoWidget::paintEngine")
}
}
func (ptr *QVideoWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QVideoWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QVideoWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QVideoWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//export callbackQVideoWidget_SetMediaObject
func callbackQVideoWidget_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {

View file

@ -1279,10 +1279,16 @@ void QCameraViewfinder_FocusInEvent(void* ptr, void* event);
void QCameraViewfinder_FocusInEventDefault(void* ptr, void* event);
void QCameraViewfinder_FocusOutEvent(void* ptr, void* event);
void QCameraViewfinder_FocusOutEventDefault(void* ptr, void* event);
void QCameraViewfinder_HideEvent(void* ptr, void* event);
void QCameraViewfinder_HideEventDefault(void* ptr, void* event);
void QCameraViewfinder_LeaveEvent(void* ptr, void* event);
void QCameraViewfinder_LeaveEventDefault(void* ptr, void* event);
void* QCameraViewfinder_MinimumSizeHint(void* ptr);
void* QCameraViewfinder_MinimumSizeHintDefault(void* ptr);
void QCameraViewfinder_MoveEvent(void* ptr, void* event);
void QCameraViewfinder_MoveEventDefault(void* ptr, void* event);
void QCameraViewfinder_PaintEvent(void* ptr, void* event);
void QCameraViewfinder_PaintEventDefault(void* ptr, void* event);
void QCameraViewfinder_SetEnabled(void* ptr, char vbo);
void QCameraViewfinder_SetEnabledDefault(void* ptr, char vbo);
void QCameraViewfinder_SetStyleSheet(void* ptr, char* styleSheet);
@ -1293,6 +1299,10 @@ void QCameraViewfinder_SetWindowModified(void* ptr, char vbo);
void QCameraViewfinder_SetWindowModifiedDefault(void* ptr, char vbo);
void QCameraViewfinder_SetWindowTitle(void* ptr, char* vqs);
void QCameraViewfinder_SetWindowTitleDefault(void* ptr, char* vqs);
void QCameraViewfinder_ShowEvent(void* ptr, void* event);
void QCameraViewfinder_ShowEventDefault(void* ptr, void* event);
void* QCameraViewfinder_SizeHint(void* ptr);
void* QCameraViewfinder_SizeHintDefault(void* ptr);
void QCameraViewfinder_ChangeEvent(void* ptr, void* event);
void QCameraViewfinder_ChangeEventDefault(void* ptr, void* event);
char QCameraViewfinder_Close(void* ptr);
@ -1333,6 +1343,8 @@ void QCameraViewfinder_Raise(void* ptr);
void QCameraViewfinder_RaiseDefault(void* ptr);
void QCameraViewfinder_Repaint(void* ptr);
void QCameraViewfinder_RepaintDefault(void* ptr);
void QCameraViewfinder_ResizeEvent(void* ptr, void* event);
void QCameraViewfinder_ResizeEventDefault(void* ptr, void* event);
void QCameraViewfinder_SetDisabled(void* ptr, char disable);
void QCameraViewfinder_SetDisabledDefault(void* ptr, char disable);
void QCameraViewfinder_SetFocus2(void* ptr);
@ -1369,10 +1381,16 @@ void QCameraViewfinder_DeleteLater(void* ptr);
void QCameraViewfinder_DeleteLaterDefault(void* ptr);
void QCameraViewfinder_DisconnectNotify(void* ptr, void* sign);
void QCameraViewfinder_DisconnectNotifyDefault(void* ptr, void* sign);
char QCameraViewfinder_Event(void* ptr, void* e);
char QCameraViewfinder_EventDefault(void* ptr, void* e);
char QCameraViewfinder_EventFilter(void* ptr, void* watched, void* event);
char QCameraViewfinder_EventFilterDefault(void* ptr, void* watched, void* event);
void* QCameraViewfinder_MetaObject(void* ptr);
void* QCameraViewfinder_MetaObjectDefault(void* ptr);
int QCameraViewfinder_Metric(void* ptr, long long metric);
int QCameraViewfinder_MetricDefault(void* ptr, long long metric);
void* QCameraViewfinder_PaintEngine(void* ptr);
void* QCameraViewfinder_PaintEngineDefault(void* ptr);
void* QCameraViewfinderSettings_NewQCameraViewfinderSettings();
void* QCameraViewfinderSettings_NewQCameraViewfinderSettings2(void* other);
char QCameraViewfinderSettings_IsNull(void* ptr);
@ -1511,6 +1529,8 @@ void QGraphicsVideoItem_DeleteLater(void* ptr);
void QGraphicsVideoItem_DeleteLaterDefault(void* ptr);
void QGraphicsVideoItem_DisconnectNotify(void* ptr, void* sign);
void QGraphicsVideoItem_DisconnectNotifyDefault(void* ptr, void* sign);
char QGraphicsVideoItem_Event(void* ptr, void* e);
char QGraphicsVideoItem_EventDefault(void* ptr, void* e);
char QGraphicsVideoItem_EventFilter(void* ptr, void* watched, void* event);
char QGraphicsVideoItem_EventFilterDefault(void* ptr, void* watched, void* event);
void* QGraphicsVideoItem_MetaObject(void* ptr);
@ -3226,6 +3246,10 @@ char QVideoWidget_EventFilter(void* ptr, void* watched, void* event);
char QVideoWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QVideoWidget_MetaObject(void* ptr);
void* QVideoWidget_MetaObjectDefault(void* ptr);
int QVideoWidget_Metric(void* ptr, long long metric);
int QVideoWidget_MetricDefault(void* ptr, long long metric);
void* QVideoWidget_PaintEngine(void* ptr);
void* QVideoWidget_PaintEngineDefault(void* ptr);
char QVideoWidget_SetMediaObject(void* ptr, void* object);
char QVideoWidget_SetMediaObjectDefault(void* ptr, void* object);
void* QVideoWidgetControl_NewQVideoWidgetControl(void* parent);

View file

@ -5928,8 +5928,10 @@ public:
void connectToHost(const QHostAddress & address, quint16 port, QIODevice::OpenMode openMode) { callbackQSslSocket_ConnectToHost2(this, const_cast<QHostAddress*>(&address), port, openMode); };
void connectToHost(const QString & hostName, quint16 port, QIODevice::OpenMode openMode, QAbstractSocket::NetworkLayerProtocol protocol) { QByteArray tcf2288 = hostName.toUtf8(); QtNetwork_PackedString hostNamePacked = { const_cast<char*>(tcf2288.prepend("WHITESPACE").constData()+10), tcf2288.size()-10 };callbackQSslSocket_ConnectToHost(this, hostNamePacked, port, openMode, protocol); };
void disconnectFromHost() { callbackQSslSocket_DisconnectFromHost(this); };
bool isSequential() const { return callbackQSslSocket_IsSequential(const_cast<MyQSslSocket*>(this)) != 0; };
bool open(QIODevice::OpenMode mode) { return callbackQSslSocket_Open(this, mode) != 0; };
qint64 pos() const { return callbackQSslSocket_Pos(const_cast<MyQSslSocket*>(this)); };
qint64 readLineData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQSslSocket_ReadLineData(this, dataPacked, maxSize); };
bool reset() { return callbackQSslSocket_Reset(this) != 0; };
bool seek(qint64 pos) { return callbackQSslSocket_Seek(this, pos) != 0; };
qint64 size() const { return callbackQSslSocket_Size(const_cast<MyQSslSocket*>(this)); };
@ -6419,6 +6421,16 @@ void QSslSocket_DisconnectFromHostDefault(void* ptr)
static_cast<QSslSocket*>(ptr)->QSslSocket::disconnectFromHost();
}
char QSslSocket_IsSequential(void* ptr)
{
return static_cast<QSslSocket*>(ptr)->isSequential();
}
char QSslSocket_IsSequentialDefault(void* ptr)
{
return static_cast<QSslSocket*>(ptr)->QSslSocket::isSequential();
}
char QSslSocket_Open(void* ptr, long long mode)
{
return static_cast<QSslSocket*>(ptr)->open(static_cast<QIODevice::OpenModeFlag>(mode));
@ -6439,6 +6451,16 @@ long long QSslSocket_PosDefault(void* ptr)
return static_cast<QSslSocket*>(ptr)->QSslSocket::pos();
}
long long QSslSocket_ReadLineData(void* ptr, char* data, long long maxSize)
{
return static_cast<QSslSocket*>(ptr)->readLineData(data, maxSize);
}
long long QSslSocket_ReadLineDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QSslSocket*>(ptr)->QSslSocket::readLineData(data, maxSize);
}
char QSslSocket_Reset(void* ptr)
{
return static_cast<QSslSocket*>(ptr)->reset();
@ -6823,11 +6845,21 @@ public:
QVariant socketOption(QAbstractSocket::SocketOption option) { return *static_cast<QVariant*>(callbackQTcpSocket_SocketOption(this, option)); };
bool waitForConnected(int msecs) { return callbackQTcpSocket_WaitForConnected(this, msecs) != 0; };
bool waitForDisconnected(int msecs) { return callbackQTcpSocket_WaitForDisconnected(this, msecs) != 0; };
bool atEnd() const { return callbackQTcpSocket_AtEnd(const_cast<MyQTcpSocket*>(this)) != 0; };
qint64 bytesAvailable() const { return callbackQTcpSocket_BytesAvailable(const_cast<MyQTcpSocket*>(this)); };
qint64 bytesToWrite() const { return callbackQTcpSocket_BytesToWrite(const_cast<MyQTcpSocket*>(this)); };
bool canReadLine() const { return callbackQTcpSocket_CanReadLine(const_cast<MyQTcpSocket*>(this)) != 0; };
void close() { callbackQTcpSocket_Close(this); };
bool isSequential() const { return callbackQTcpSocket_IsSequential(const_cast<MyQTcpSocket*>(this)) != 0; };
bool open(QIODevice::OpenMode mode) { return callbackQTcpSocket_Open(this, mode) != 0; };
qint64 pos() const { return callbackQTcpSocket_Pos(const_cast<MyQTcpSocket*>(this)); };
qint64 readLineData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQTcpSocket_ReadLineData(this, dataPacked, maxSize); };
bool reset() { return callbackQTcpSocket_Reset(this) != 0; };
bool seek(qint64 pos) { return callbackQTcpSocket_Seek(this, pos) != 0; };
qint64 size() const { return callbackQTcpSocket_Size(const_cast<MyQTcpSocket*>(this)); };
bool waitForBytesWritten(int msecs) { return callbackQTcpSocket_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQTcpSocket_WaitForReadyRead(this, msecs) != 0; };
qint64 writeData(const char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { const_cast<char*>(data), maxSize };return callbackQTcpSocket_WriteData(this, dataPacked, maxSize); };
void timerEvent(QTimerEvent * event) { callbackQTcpSocket_TimerEvent(this, event); };
void childEvent(QChildEvent * event) { callbackQTcpSocket_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQTcpSocket_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
@ -6944,6 +6976,66 @@ char QTcpSocket_WaitForDisconnectedDefault(void* ptr, int msecs)
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::waitForDisconnected(msecs);
}
char QTcpSocket_AtEnd(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->atEnd();
}
char QTcpSocket_AtEndDefault(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::atEnd();
}
long long QTcpSocket_BytesAvailable(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->bytesAvailable();
}
long long QTcpSocket_BytesAvailableDefault(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::bytesAvailable();
}
long long QTcpSocket_BytesToWrite(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->bytesToWrite();
}
long long QTcpSocket_BytesToWriteDefault(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::bytesToWrite();
}
char QTcpSocket_CanReadLine(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->canReadLine();
}
char QTcpSocket_CanReadLineDefault(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::canReadLine();
}
void QTcpSocket_Close(void* ptr)
{
static_cast<QTcpSocket*>(ptr)->close();
}
void QTcpSocket_CloseDefault(void* ptr)
{
static_cast<QTcpSocket*>(ptr)->QTcpSocket::close();
}
char QTcpSocket_IsSequential(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->isSequential();
}
char QTcpSocket_IsSequentialDefault(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::isSequential();
}
char QTcpSocket_Open(void* ptr, long long mode)
{
return static_cast<QTcpSocket*>(ptr)->open(static_cast<QIODevice::OpenModeFlag>(mode));
@ -6964,6 +7056,16 @@ long long QTcpSocket_PosDefault(void* ptr)
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::pos();
}
long long QTcpSocket_ReadLineData(void* ptr, char* data, long long maxSize)
{
return static_cast<QTcpSocket*>(ptr)->readLineData(data, maxSize);
}
long long QTcpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::readLineData(data, maxSize);
}
char QTcpSocket_Reset(void* ptr)
{
return static_cast<QTcpSocket*>(ptr)->reset();
@ -6994,6 +7096,36 @@ long long QTcpSocket_SizeDefault(void* ptr)
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::size();
}
char QTcpSocket_WaitForBytesWritten(void* ptr, int msecs)
{
return static_cast<QTcpSocket*>(ptr)->waitForBytesWritten(msecs);
}
char QTcpSocket_WaitForBytesWrittenDefault(void* ptr, int msecs)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::waitForBytesWritten(msecs);
}
char QTcpSocket_WaitForReadyRead(void* ptr, int msecs)
{
return static_cast<QTcpSocket*>(ptr)->waitForReadyRead(msecs);
}
char QTcpSocket_WaitForReadyReadDefault(void* ptr, int msecs)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::waitForReadyRead(msecs);
}
long long QTcpSocket_WriteData(void* ptr, char* data, long long maxSize)
{
return static_cast<QTcpSocket*>(ptr)->writeData(const_cast<const char*>(data), maxSize);
}
long long QTcpSocket_WriteDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QTcpSocket*>(ptr)->QTcpSocket::writeData(const_cast<const char*>(data), maxSize);
}
void QTcpSocket_TimerEvent(void* ptr, void* event)
{
static_cast<QTcpSocket*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
@ -7098,11 +7230,21 @@ public:
QVariant socketOption(QAbstractSocket::SocketOption option) { return *static_cast<QVariant*>(callbackQUdpSocket_SocketOption(this, option)); };
bool waitForConnected(int msecs) { return callbackQUdpSocket_WaitForConnected(this, msecs) != 0; };
bool waitForDisconnected(int msecs) { return callbackQUdpSocket_WaitForDisconnected(this, msecs) != 0; };
bool atEnd() const { return callbackQUdpSocket_AtEnd(const_cast<MyQUdpSocket*>(this)) != 0; };
qint64 bytesAvailable() const { return callbackQUdpSocket_BytesAvailable(const_cast<MyQUdpSocket*>(this)); };
qint64 bytesToWrite() const { return callbackQUdpSocket_BytesToWrite(const_cast<MyQUdpSocket*>(this)); };
bool canReadLine() const { return callbackQUdpSocket_CanReadLine(const_cast<MyQUdpSocket*>(this)) != 0; };
void close() { callbackQUdpSocket_Close(this); };
bool isSequential() const { return callbackQUdpSocket_IsSequential(const_cast<MyQUdpSocket*>(this)) != 0; };
bool open(QIODevice::OpenMode mode) { return callbackQUdpSocket_Open(this, mode) != 0; };
qint64 pos() const { return callbackQUdpSocket_Pos(const_cast<MyQUdpSocket*>(this)); };
qint64 readLineData(char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { data, maxSize };return callbackQUdpSocket_ReadLineData(this, dataPacked, maxSize); };
bool reset() { return callbackQUdpSocket_Reset(this) != 0; };
bool seek(qint64 pos) { return callbackQUdpSocket_Seek(this, pos) != 0; };
qint64 size() const { return callbackQUdpSocket_Size(const_cast<MyQUdpSocket*>(this)); };
bool waitForBytesWritten(int msecs) { return callbackQUdpSocket_WaitForBytesWritten(this, msecs) != 0; };
bool waitForReadyRead(int msecs) { return callbackQUdpSocket_WaitForReadyRead(this, msecs) != 0; };
qint64 writeData(const char * data, qint64 maxSize) { QtNetwork_PackedString dataPacked = { const_cast<char*>(data), maxSize };return callbackQUdpSocket_WriteData(this, dataPacked, maxSize); };
void timerEvent(QTimerEvent * event) { callbackQUdpSocket_TimerEvent(this, event); };
void childEvent(QChildEvent * event) { callbackQUdpSocket_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQUdpSocket_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
@ -7274,6 +7416,66 @@ char QUdpSocket_WaitForDisconnectedDefault(void* ptr, int msecs)
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::waitForDisconnected(msecs);
}
char QUdpSocket_AtEnd(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->atEnd();
}
char QUdpSocket_AtEndDefault(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::atEnd();
}
long long QUdpSocket_BytesAvailable(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->bytesAvailable();
}
long long QUdpSocket_BytesAvailableDefault(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::bytesAvailable();
}
long long QUdpSocket_BytesToWrite(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->bytesToWrite();
}
long long QUdpSocket_BytesToWriteDefault(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::bytesToWrite();
}
char QUdpSocket_CanReadLine(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->canReadLine();
}
char QUdpSocket_CanReadLineDefault(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::canReadLine();
}
void QUdpSocket_Close(void* ptr)
{
static_cast<QUdpSocket*>(ptr)->close();
}
void QUdpSocket_CloseDefault(void* ptr)
{
static_cast<QUdpSocket*>(ptr)->QUdpSocket::close();
}
char QUdpSocket_IsSequential(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->isSequential();
}
char QUdpSocket_IsSequentialDefault(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::isSequential();
}
char QUdpSocket_Open(void* ptr, long long mode)
{
return static_cast<QUdpSocket*>(ptr)->open(static_cast<QIODevice::OpenModeFlag>(mode));
@ -7294,6 +7496,16 @@ long long QUdpSocket_PosDefault(void* ptr)
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::pos();
}
long long QUdpSocket_ReadLineData(void* ptr, char* data, long long maxSize)
{
return static_cast<QUdpSocket*>(ptr)->readLineData(data, maxSize);
}
long long QUdpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::readLineData(data, maxSize);
}
char QUdpSocket_Reset(void* ptr)
{
return static_cast<QUdpSocket*>(ptr)->reset();
@ -7324,6 +7536,36 @@ long long QUdpSocket_SizeDefault(void* ptr)
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::size();
}
char QUdpSocket_WaitForBytesWritten(void* ptr, int msecs)
{
return static_cast<QUdpSocket*>(ptr)->waitForBytesWritten(msecs);
}
char QUdpSocket_WaitForBytesWrittenDefault(void* ptr, int msecs)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::waitForBytesWritten(msecs);
}
char QUdpSocket_WaitForReadyRead(void* ptr, int msecs)
{
return static_cast<QUdpSocket*>(ptr)->waitForReadyRead(msecs);
}
char QUdpSocket_WaitForReadyReadDefault(void* ptr, int msecs)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::waitForReadyRead(msecs);
}
long long QUdpSocket_WriteData(void* ptr, char* data, long long maxSize)
{
return static_cast<QUdpSocket*>(ptr)->writeData(const_cast<const char*>(data), maxSize);
}
long long QUdpSocket_WriteDataDefault(void* ptr, char* data, long long maxSize)
{
return static_cast<QUdpSocket*>(ptr)->QUdpSocket::writeData(const_cast<const char*>(data), maxSize);
}
void QUdpSocket_TimerEvent(void* ptr, void* event)
{
static_cast<QUdpSocket*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));

View file

@ -16369,6 +16369,44 @@ func (ptr *QSslSocket) DisconnectFromHostDefault() {
}
}
//export callbackQSslSocket_IsSequential
func callbackQSslSocket_IsSequential(ptr unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSslSocket::isSequential"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
}
return C.char(int8(qt.GoBoolToInt(NewQSslSocketFromPointer(ptr).IsSequentialDefault())))
}
func (ptr *QSslSocket) ConnectIsSequential(f func() bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSslSocket::isSequential", f)
}
}
func (ptr *QSslSocket) DisconnectIsSequential() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSslSocket::isSequential")
}
}
func (ptr *QSslSocket) IsSequential() bool {
if ptr.Pointer() != nil {
return C.QSslSocket_IsSequential(ptr.Pointer()) != 0
}
return false
}
func (ptr *QSslSocket) IsSequentialDefault() bool {
if ptr.Pointer() != nil {
return C.QSslSocket_IsSequentialDefault(ptr.Pointer()) != 0
}
return false
}
//export callbackQSslSocket_Open
func callbackQSslSocket_Open(ptr unsafe.Pointer, mode C.longlong) C.char {
@ -16445,6 +16483,48 @@ func (ptr *QSslSocket) PosDefault() int64 {
return 0
}
//export callbackQSslSocket_ReadLineData
func callbackQSslSocket_ReadLineData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSslSocket::readLineData"); signal != nil {
return C.longlong(signal.(func(string, int64) int64)(cGoUnpackString(data), int64(maxSize)))
}
return C.longlong(NewQSslSocketFromPointer(ptr).ReadLineDataDefault(cGoUnpackString(data), int64(maxSize)))
}
func (ptr *QSslSocket) ConnectReadLineData(f func(data string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSslSocket::readLineData", f)
}
}
func (ptr *QSslSocket) DisconnectReadLineData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSslSocket::readLineData")
}
}
func (ptr *QSslSocket) ReadLineData(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QSslSocket_ReadLineData(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
func (ptr *QSslSocket) ReadLineDataDefault(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QSslSocket_ReadLineDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
//export callbackQSslSocket_Reset
func callbackQSslSocket_Reset(ptr unsafe.Pointer) C.char {
@ -17980,6 +18060,232 @@ func (ptr *QTcpSocket) WaitForDisconnectedDefault(msecs int) bool {
return false
}
//export callbackQTcpSocket_AtEnd
func callbackQTcpSocket_AtEnd(ptr unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::atEnd"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
}
return C.char(int8(qt.GoBoolToInt(NewQTcpSocketFromPointer(ptr).AtEndDefault())))
}
func (ptr *QTcpSocket) ConnectAtEnd(f func() bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::atEnd", f)
}
}
func (ptr *QTcpSocket) DisconnectAtEnd() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::atEnd")
}
}
func (ptr *QTcpSocket) AtEnd() bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_AtEnd(ptr.Pointer()) != 0
}
return false
}
func (ptr *QTcpSocket) AtEndDefault() bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_AtEndDefault(ptr.Pointer()) != 0
}
return false
}
//export callbackQTcpSocket_BytesAvailable
func callbackQTcpSocket_BytesAvailable(ptr unsafe.Pointer) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::bytesAvailable"); signal != nil {
return C.longlong(signal.(func() int64)())
}
return C.longlong(NewQTcpSocketFromPointer(ptr).BytesAvailableDefault())
}
func (ptr *QTcpSocket) ConnectBytesAvailable(f func() int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::bytesAvailable", f)
}
}
func (ptr *QTcpSocket) DisconnectBytesAvailable() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::bytesAvailable")
}
}
func (ptr *QTcpSocket) BytesAvailable() int64 {
if ptr.Pointer() != nil {
return int64(C.QTcpSocket_BytesAvailable(ptr.Pointer()))
}
return 0
}
func (ptr *QTcpSocket) BytesAvailableDefault() int64 {
if ptr.Pointer() != nil {
return int64(C.QTcpSocket_BytesAvailableDefault(ptr.Pointer()))
}
return 0
}
//export callbackQTcpSocket_BytesToWrite
func callbackQTcpSocket_BytesToWrite(ptr unsafe.Pointer) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::bytesToWrite"); signal != nil {
return C.longlong(signal.(func() int64)())
}
return C.longlong(NewQTcpSocketFromPointer(ptr).BytesToWriteDefault())
}
func (ptr *QTcpSocket) ConnectBytesToWrite(f func() int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::bytesToWrite", f)
}
}
func (ptr *QTcpSocket) DisconnectBytesToWrite() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::bytesToWrite")
}
}
func (ptr *QTcpSocket) BytesToWrite() int64 {
if ptr.Pointer() != nil {
return int64(C.QTcpSocket_BytesToWrite(ptr.Pointer()))
}
return 0
}
func (ptr *QTcpSocket) BytesToWriteDefault() int64 {
if ptr.Pointer() != nil {
return int64(C.QTcpSocket_BytesToWriteDefault(ptr.Pointer()))
}
return 0
}
//export callbackQTcpSocket_CanReadLine
func callbackQTcpSocket_CanReadLine(ptr unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::canReadLine"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
}
return C.char(int8(qt.GoBoolToInt(NewQTcpSocketFromPointer(ptr).CanReadLineDefault())))
}
func (ptr *QTcpSocket) ConnectCanReadLine(f func() bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::canReadLine", f)
}
}
func (ptr *QTcpSocket) DisconnectCanReadLine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::canReadLine")
}
}
func (ptr *QTcpSocket) CanReadLine() bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_CanReadLine(ptr.Pointer()) != 0
}
return false
}
func (ptr *QTcpSocket) CanReadLineDefault() bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_CanReadLineDefault(ptr.Pointer()) != 0
}
return false
}
//export callbackQTcpSocket_Close
func callbackQTcpSocket_Close(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::close"); signal != nil {
signal.(func())()
} else {
NewQTcpSocketFromPointer(ptr).CloseDefault()
}
}
func (ptr *QTcpSocket) ConnectClose(f func()) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::close", f)
}
}
func (ptr *QTcpSocket) DisconnectClose() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::close")
}
}
func (ptr *QTcpSocket) Close() {
if ptr.Pointer() != nil {
C.QTcpSocket_Close(ptr.Pointer())
}
}
func (ptr *QTcpSocket) CloseDefault() {
if ptr.Pointer() != nil {
C.QTcpSocket_CloseDefault(ptr.Pointer())
}
}
//export callbackQTcpSocket_IsSequential
func callbackQTcpSocket_IsSequential(ptr unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::isSequential"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
}
return C.char(int8(qt.GoBoolToInt(NewQTcpSocketFromPointer(ptr).IsSequentialDefault())))
}
func (ptr *QTcpSocket) ConnectIsSequential(f func() bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::isSequential", f)
}
}
func (ptr *QTcpSocket) DisconnectIsSequential() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::isSequential")
}
}
func (ptr *QTcpSocket) IsSequential() bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_IsSequential(ptr.Pointer()) != 0
}
return false
}
func (ptr *QTcpSocket) IsSequentialDefault() bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_IsSequentialDefault(ptr.Pointer()) != 0
}
return false
}
//export callbackQTcpSocket_Open
func callbackQTcpSocket_Open(ptr unsafe.Pointer, mode C.longlong) C.char {
@ -18056,6 +18362,48 @@ func (ptr *QTcpSocket) PosDefault() int64 {
return 0
}
//export callbackQTcpSocket_ReadLineData
func callbackQTcpSocket_ReadLineData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::readLineData"); signal != nil {
return C.longlong(signal.(func(string, int64) int64)(cGoUnpackString(data), int64(maxSize)))
}
return C.longlong(NewQTcpSocketFromPointer(ptr).ReadLineDataDefault(cGoUnpackString(data), int64(maxSize)))
}
func (ptr *QTcpSocket) ConnectReadLineData(f func(data string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::readLineData", f)
}
}
func (ptr *QTcpSocket) DisconnectReadLineData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::readLineData")
}
}
func (ptr *QTcpSocket) ReadLineData(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QTcpSocket_ReadLineData(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
func (ptr *QTcpSocket) ReadLineDataDefault(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QTcpSocket_ReadLineDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
//export callbackQTcpSocket_Reset
func callbackQTcpSocket_Reset(ptr unsafe.Pointer) C.char {
@ -18170,6 +18518,124 @@ func (ptr *QTcpSocket) SizeDefault() int64 {
return 0
}
//export callbackQTcpSocket_WaitForBytesWritten
func callbackQTcpSocket_WaitForBytesWritten(ptr unsafe.Pointer, msecs C.int) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::waitForBytesWritten"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int) bool)(int(int32(msecs))))))
}
return C.char(int8(qt.GoBoolToInt(NewQTcpSocketFromPointer(ptr).WaitForBytesWrittenDefault(int(int32(msecs))))))
}
func (ptr *QTcpSocket) ConnectWaitForBytesWritten(f func(msecs int) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::waitForBytesWritten", f)
}
}
func (ptr *QTcpSocket) DisconnectWaitForBytesWritten() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::waitForBytesWritten")
}
}
func (ptr *QTcpSocket) WaitForBytesWritten(msecs int) bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_WaitForBytesWritten(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
func (ptr *QTcpSocket) WaitForBytesWrittenDefault(msecs int) bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
//export callbackQTcpSocket_WaitForReadyRead
func callbackQTcpSocket_WaitForReadyRead(ptr unsafe.Pointer, msecs C.int) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::waitForReadyRead"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int) bool)(int(int32(msecs))))))
}
return C.char(int8(qt.GoBoolToInt(NewQTcpSocketFromPointer(ptr).WaitForReadyReadDefault(int(int32(msecs))))))
}
func (ptr *QTcpSocket) ConnectWaitForReadyRead(f func(msecs int) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::waitForReadyRead", f)
}
}
func (ptr *QTcpSocket) DisconnectWaitForReadyRead() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::waitForReadyRead")
}
}
func (ptr *QTcpSocket) WaitForReadyRead(msecs int) bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_WaitForReadyRead(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
func (ptr *QTcpSocket) WaitForReadyReadDefault(msecs int) bool {
if ptr.Pointer() != nil {
return C.QTcpSocket_WaitForReadyReadDefault(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
//export callbackQTcpSocket_WriteData
func callbackQTcpSocket_WriteData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QTcpSocket::writeData"); signal != nil {
return C.longlong(signal.(func(string, int64) int64)(cGoUnpackString(data), int64(maxSize)))
}
return C.longlong(NewQTcpSocketFromPointer(ptr).WriteDataDefault(cGoUnpackString(data), int64(maxSize)))
}
func (ptr *QTcpSocket) ConnectWriteData(f func(data string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::writeData", f)
}
}
func (ptr *QTcpSocket) DisconnectWriteData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QTcpSocket::writeData")
}
}
func (ptr *QTcpSocket) WriteData(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QTcpSocket_WriteData(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
func (ptr *QTcpSocket) WriteDataDefault(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QTcpSocket_WriteDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
//export callbackQTcpSocket_TimerEvent
func callbackQTcpSocket_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
@ -19009,6 +19475,232 @@ func (ptr *QUdpSocket) WaitForDisconnectedDefault(msecs int) bool {
return false
}
//export callbackQUdpSocket_AtEnd
func callbackQUdpSocket_AtEnd(ptr unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::atEnd"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
}
return C.char(int8(qt.GoBoolToInt(NewQUdpSocketFromPointer(ptr).AtEndDefault())))
}
func (ptr *QUdpSocket) ConnectAtEnd(f func() bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::atEnd", f)
}
}
func (ptr *QUdpSocket) DisconnectAtEnd() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::atEnd")
}
}
func (ptr *QUdpSocket) AtEnd() bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_AtEnd(ptr.Pointer()) != 0
}
return false
}
func (ptr *QUdpSocket) AtEndDefault() bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_AtEndDefault(ptr.Pointer()) != 0
}
return false
}
//export callbackQUdpSocket_BytesAvailable
func callbackQUdpSocket_BytesAvailable(ptr unsafe.Pointer) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::bytesAvailable"); signal != nil {
return C.longlong(signal.(func() int64)())
}
return C.longlong(NewQUdpSocketFromPointer(ptr).BytesAvailableDefault())
}
func (ptr *QUdpSocket) ConnectBytesAvailable(f func() int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::bytesAvailable", f)
}
}
func (ptr *QUdpSocket) DisconnectBytesAvailable() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::bytesAvailable")
}
}
func (ptr *QUdpSocket) BytesAvailable() int64 {
if ptr.Pointer() != nil {
return int64(C.QUdpSocket_BytesAvailable(ptr.Pointer()))
}
return 0
}
func (ptr *QUdpSocket) BytesAvailableDefault() int64 {
if ptr.Pointer() != nil {
return int64(C.QUdpSocket_BytesAvailableDefault(ptr.Pointer()))
}
return 0
}
//export callbackQUdpSocket_BytesToWrite
func callbackQUdpSocket_BytesToWrite(ptr unsafe.Pointer) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::bytesToWrite"); signal != nil {
return C.longlong(signal.(func() int64)())
}
return C.longlong(NewQUdpSocketFromPointer(ptr).BytesToWriteDefault())
}
func (ptr *QUdpSocket) ConnectBytesToWrite(f func() int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::bytesToWrite", f)
}
}
func (ptr *QUdpSocket) DisconnectBytesToWrite() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::bytesToWrite")
}
}
func (ptr *QUdpSocket) BytesToWrite() int64 {
if ptr.Pointer() != nil {
return int64(C.QUdpSocket_BytesToWrite(ptr.Pointer()))
}
return 0
}
func (ptr *QUdpSocket) BytesToWriteDefault() int64 {
if ptr.Pointer() != nil {
return int64(C.QUdpSocket_BytesToWriteDefault(ptr.Pointer()))
}
return 0
}
//export callbackQUdpSocket_CanReadLine
func callbackQUdpSocket_CanReadLine(ptr unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::canReadLine"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
}
return C.char(int8(qt.GoBoolToInt(NewQUdpSocketFromPointer(ptr).CanReadLineDefault())))
}
func (ptr *QUdpSocket) ConnectCanReadLine(f func() bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::canReadLine", f)
}
}
func (ptr *QUdpSocket) DisconnectCanReadLine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::canReadLine")
}
}
func (ptr *QUdpSocket) CanReadLine() bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_CanReadLine(ptr.Pointer()) != 0
}
return false
}
func (ptr *QUdpSocket) CanReadLineDefault() bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_CanReadLineDefault(ptr.Pointer()) != 0
}
return false
}
//export callbackQUdpSocket_Close
func callbackQUdpSocket_Close(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::close"); signal != nil {
signal.(func())()
} else {
NewQUdpSocketFromPointer(ptr).CloseDefault()
}
}
func (ptr *QUdpSocket) ConnectClose(f func()) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::close", f)
}
}
func (ptr *QUdpSocket) DisconnectClose() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::close")
}
}
func (ptr *QUdpSocket) Close() {
if ptr.Pointer() != nil {
C.QUdpSocket_Close(ptr.Pointer())
}
}
func (ptr *QUdpSocket) CloseDefault() {
if ptr.Pointer() != nil {
C.QUdpSocket_CloseDefault(ptr.Pointer())
}
}
//export callbackQUdpSocket_IsSequential
func callbackQUdpSocket_IsSequential(ptr unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::isSequential"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
}
return C.char(int8(qt.GoBoolToInt(NewQUdpSocketFromPointer(ptr).IsSequentialDefault())))
}
func (ptr *QUdpSocket) ConnectIsSequential(f func() bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::isSequential", f)
}
}
func (ptr *QUdpSocket) DisconnectIsSequential() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::isSequential")
}
}
func (ptr *QUdpSocket) IsSequential() bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_IsSequential(ptr.Pointer()) != 0
}
return false
}
func (ptr *QUdpSocket) IsSequentialDefault() bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_IsSequentialDefault(ptr.Pointer()) != 0
}
return false
}
//export callbackQUdpSocket_Open
func callbackQUdpSocket_Open(ptr unsafe.Pointer, mode C.longlong) C.char {
@ -19085,6 +19777,48 @@ func (ptr *QUdpSocket) PosDefault() int64 {
return 0
}
//export callbackQUdpSocket_ReadLineData
func callbackQUdpSocket_ReadLineData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::readLineData"); signal != nil {
return C.longlong(signal.(func(string, int64) int64)(cGoUnpackString(data), int64(maxSize)))
}
return C.longlong(NewQUdpSocketFromPointer(ptr).ReadLineDataDefault(cGoUnpackString(data), int64(maxSize)))
}
func (ptr *QUdpSocket) ConnectReadLineData(f func(data string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::readLineData", f)
}
}
func (ptr *QUdpSocket) DisconnectReadLineData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::readLineData")
}
}
func (ptr *QUdpSocket) ReadLineData(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QUdpSocket_ReadLineData(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
func (ptr *QUdpSocket) ReadLineDataDefault(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QUdpSocket_ReadLineDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
//export callbackQUdpSocket_Reset
func callbackQUdpSocket_Reset(ptr unsafe.Pointer) C.char {
@ -19199,6 +19933,124 @@ func (ptr *QUdpSocket) SizeDefault() int64 {
return 0
}
//export callbackQUdpSocket_WaitForBytesWritten
func callbackQUdpSocket_WaitForBytesWritten(ptr unsafe.Pointer, msecs C.int) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::waitForBytesWritten"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int) bool)(int(int32(msecs))))))
}
return C.char(int8(qt.GoBoolToInt(NewQUdpSocketFromPointer(ptr).WaitForBytesWrittenDefault(int(int32(msecs))))))
}
func (ptr *QUdpSocket) ConnectWaitForBytesWritten(f func(msecs int) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::waitForBytesWritten", f)
}
}
func (ptr *QUdpSocket) DisconnectWaitForBytesWritten() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::waitForBytesWritten")
}
}
func (ptr *QUdpSocket) WaitForBytesWritten(msecs int) bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_WaitForBytesWritten(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
func (ptr *QUdpSocket) WaitForBytesWrittenDefault(msecs int) bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_WaitForBytesWrittenDefault(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
//export callbackQUdpSocket_WaitForReadyRead
func callbackQUdpSocket_WaitForReadyRead(ptr unsafe.Pointer, msecs C.int) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::waitForReadyRead"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int) bool)(int(int32(msecs))))))
}
return C.char(int8(qt.GoBoolToInt(NewQUdpSocketFromPointer(ptr).WaitForReadyReadDefault(int(int32(msecs))))))
}
func (ptr *QUdpSocket) ConnectWaitForReadyRead(f func(msecs int) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::waitForReadyRead", f)
}
}
func (ptr *QUdpSocket) DisconnectWaitForReadyRead() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::waitForReadyRead")
}
}
func (ptr *QUdpSocket) WaitForReadyRead(msecs int) bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_WaitForReadyRead(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
func (ptr *QUdpSocket) WaitForReadyReadDefault(msecs int) bool {
if ptr.Pointer() != nil {
return C.QUdpSocket_WaitForReadyReadDefault(ptr.Pointer(), C.int(int32(msecs))) != 0
}
return false
}
//export callbackQUdpSocket_WriteData
func callbackQUdpSocket_WriteData(ptr unsafe.Pointer, data C.struct_QtNetwork_PackedString, maxSize C.longlong) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QUdpSocket::writeData"); signal != nil {
return C.longlong(signal.(func(string, int64) int64)(cGoUnpackString(data), int64(maxSize)))
}
return C.longlong(NewQUdpSocketFromPointer(ptr).WriteDataDefault(cGoUnpackString(data), int64(maxSize)))
}
func (ptr *QUdpSocket) ConnectWriteData(f func(data string, maxSize int64) int64) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::writeData", f)
}
}
func (ptr *QUdpSocket) DisconnectWriteData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QUdpSocket::writeData")
}
}
func (ptr *QUdpSocket) WriteData(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QUdpSocket_WriteData(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
func (ptr *QUdpSocket) WriteDataDefault(data string, maxSize int64) int64 {
if ptr.Pointer() != nil {
var dataC = C.CString(data)
defer C.free(unsafe.Pointer(dataC))
return int64(C.QUdpSocket_WriteDataDefault(ptr.Pointer(), dataC, C.longlong(maxSize)))
}
return 0
}
//export callbackQUdpSocket_TimerEvent
func callbackQUdpSocket_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {

View file

@ -1215,10 +1215,14 @@ void QSslSocket_ConnectToHost(void* ptr, char* hostName, unsigned short port, lo
void QSslSocket_ConnectToHostDefault(void* ptr, char* hostName, unsigned short port, long long openMode, long long protocol);
void QSslSocket_DisconnectFromHost(void* ptr);
void QSslSocket_DisconnectFromHostDefault(void* ptr);
char QSslSocket_IsSequential(void* ptr);
char QSslSocket_IsSequentialDefault(void* ptr);
char QSslSocket_Open(void* ptr, long long mode);
char QSslSocket_OpenDefault(void* ptr, long long mode);
long long QSslSocket_Pos(void* ptr);
long long QSslSocket_PosDefault(void* ptr);
long long QSslSocket_ReadLineData(void* ptr, char* data, long long maxSize);
long long QSslSocket_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
char QSslSocket_Reset(void* ptr);
char QSslSocket_ResetDefault(void* ptr);
char QSslSocket_Seek(void* ptr, long long pos);
@ -1310,16 +1314,36 @@ char QTcpSocket_WaitForConnected(void* ptr, int msecs);
char QTcpSocket_WaitForConnectedDefault(void* ptr, int msecs);
char QTcpSocket_WaitForDisconnected(void* ptr, int msecs);
char QTcpSocket_WaitForDisconnectedDefault(void* ptr, int msecs);
char QTcpSocket_AtEnd(void* ptr);
char QTcpSocket_AtEndDefault(void* ptr);
long long QTcpSocket_BytesAvailable(void* ptr);
long long QTcpSocket_BytesAvailableDefault(void* ptr);
long long QTcpSocket_BytesToWrite(void* ptr);
long long QTcpSocket_BytesToWriteDefault(void* ptr);
char QTcpSocket_CanReadLine(void* ptr);
char QTcpSocket_CanReadLineDefault(void* ptr);
void QTcpSocket_Close(void* ptr);
void QTcpSocket_CloseDefault(void* ptr);
char QTcpSocket_IsSequential(void* ptr);
char QTcpSocket_IsSequentialDefault(void* ptr);
char QTcpSocket_Open(void* ptr, long long mode);
char QTcpSocket_OpenDefault(void* ptr, long long mode);
long long QTcpSocket_Pos(void* ptr);
long long QTcpSocket_PosDefault(void* ptr);
long long QTcpSocket_ReadLineData(void* ptr, char* data, long long maxSize);
long long QTcpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
char QTcpSocket_Reset(void* ptr);
char QTcpSocket_ResetDefault(void* ptr);
char QTcpSocket_Seek(void* ptr, long long pos);
char QTcpSocket_SeekDefault(void* ptr, long long pos);
long long QTcpSocket_Size(void* ptr);
long long QTcpSocket_SizeDefault(void* ptr);
char QTcpSocket_WaitForBytesWritten(void* ptr, int msecs);
char QTcpSocket_WaitForBytesWrittenDefault(void* ptr, int msecs);
char QTcpSocket_WaitForReadyRead(void* ptr, int msecs);
char QTcpSocket_WaitForReadyReadDefault(void* ptr, int msecs);
long long QTcpSocket_WriteData(void* ptr, char* data, long long maxSize);
long long QTcpSocket_WriteDataDefault(void* ptr, char* data, long long maxSize);
void QTcpSocket_TimerEvent(void* ptr, void* event);
void QTcpSocket_TimerEventDefault(void* ptr, void* event);
void QTcpSocket_ChildEvent(void* ptr, void* event);
@ -1370,16 +1394,36 @@ char QUdpSocket_WaitForConnected(void* ptr, int msecs);
char QUdpSocket_WaitForConnectedDefault(void* ptr, int msecs);
char QUdpSocket_WaitForDisconnected(void* ptr, int msecs);
char QUdpSocket_WaitForDisconnectedDefault(void* ptr, int msecs);
char QUdpSocket_AtEnd(void* ptr);
char QUdpSocket_AtEndDefault(void* ptr);
long long QUdpSocket_BytesAvailable(void* ptr);
long long QUdpSocket_BytesAvailableDefault(void* ptr);
long long QUdpSocket_BytesToWrite(void* ptr);
long long QUdpSocket_BytesToWriteDefault(void* ptr);
char QUdpSocket_CanReadLine(void* ptr);
char QUdpSocket_CanReadLineDefault(void* ptr);
void QUdpSocket_Close(void* ptr);
void QUdpSocket_CloseDefault(void* ptr);
char QUdpSocket_IsSequential(void* ptr);
char QUdpSocket_IsSequentialDefault(void* ptr);
char QUdpSocket_Open(void* ptr, long long mode);
char QUdpSocket_OpenDefault(void* ptr, long long mode);
long long QUdpSocket_Pos(void* ptr);
long long QUdpSocket_PosDefault(void* ptr);
long long QUdpSocket_ReadLineData(void* ptr, char* data, long long maxSize);
long long QUdpSocket_ReadLineDataDefault(void* ptr, char* data, long long maxSize);
char QUdpSocket_Reset(void* ptr);
char QUdpSocket_ResetDefault(void* ptr);
char QUdpSocket_Seek(void* ptr, long long pos);
char QUdpSocket_SeekDefault(void* ptr, long long pos);
long long QUdpSocket_Size(void* ptr);
long long QUdpSocket_SizeDefault(void* ptr);
char QUdpSocket_WaitForBytesWritten(void* ptr, int msecs);
char QUdpSocket_WaitForBytesWrittenDefault(void* ptr, int msecs);
char QUdpSocket_WaitForReadyRead(void* ptr, int msecs);
char QUdpSocket_WaitForReadyReadDefault(void* ptr, int msecs);
long long QUdpSocket_WriteData(void* ptr, char* data, long long maxSize);
long long QUdpSocket_WriteDataDefault(void* ptr, char* data, long long maxSize);
void QUdpSocket_TimerEvent(void* ptr, void* event);
void QUdpSocket_TimerEventDefault(void* ptr, void* event);
void QUdpSocket_ChildEvent(void* ptr, void* event);

View file

@ -128,7 +128,11 @@ public:
void customEvent(QEvent * event) { callbackQAbstractPrintDialog_CustomEvent(this, event); };
void deleteLater() { callbackQAbstractPrintDialog_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQAbstractPrintDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQAbstractPrintDialog_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQAbstractPrintDialog_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstractPrintDialog_MetaObject(const_cast<MyQAbstractPrintDialog*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQAbstractPrintDialog_Metric(const_cast<MyQAbstractPrintDialog*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQAbstractPrintDialog_PaintEngine(const_cast<MyQAbstractPrintDialog*>(this))); };
};
void* QAbstractPrintDialog_NewQAbstractPrintDialog(void* printer, void* parent)
@ -818,6 +822,26 @@ void QAbstractPrintDialog_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QAbstractPrintDialog*>(ptr)->QAbstractPrintDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QAbstractPrintDialog_Event(void* ptr, void* e)
{
return static_cast<QAbstractPrintDialog*>(ptr)->event(static_cast<QEvent*>(e));
}
char QAbstractPrintDialog_EventDefault(void* ptr, void* e)
{
return static_cast<QAbstractPrintDialog*>(ptr)->QAbstractPrintDialog::event(static_cast<QEvent*>(e));
}
char QAbstractPrintDialog_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractPrintDialog*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
char QAbstractPrintDialog_EventFilterDefault(void* ptr, void* watched, void* event)
{
return static_cast<QAbstractPrintDialog*>(ptr)->QAbstractPrintDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
void* QAbstractPrintDialog_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QAbstractPrintDialog*>(ptr)->metaObject());
@ -828,6 +852,26 @@ void* QAbstractPrintDialog_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QAbstractPrintDialog*>(ptr)->QAbstractPrintDialog::metaObject());
}
int QAbstractPrintDialog_Metric(void* ptr, long long metric)
{
return static_cast<QAbstractPrintDialog*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QAbstractPrintDialog_MetricDefault(void* ptr, long long metric)
{
return static_cast<QAbstractPrintDialog*>(ptr)->QAbstractPrintDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QAbstractPrintDialog_PaintEngine(void* ptr)
{
return static_cast<QAbstractPrintDialog*>(ptr)->paintEngine();
}
void* QAbstractPrintDialog_PaintEngineDefault(void* ptr)
{
return static_cast<QAbstractPrintDialog*>(ptr)->QAbstractPrintDialog::paintEngine();
}
void* QPageSetupDialog_Printer(void* ptr)
{
return static_cast<QPageSetupDialog*>(ptr)->printer();
@ -1470,6 +1514,26 @@ void QPageSetupDialog_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QPageSetupDialog*>(ptr)->QPageSetupDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QPageSetupDialog_Event(void* ptr, void* e)
{
return static_cast<QPageSetupDialog*>(ptr)->event(static_cast<QEvent*>(e));
}
char QPageSetupDialog_EventDefault(void* ptr, void* e)
{
return static_cast<QPageSetupDialog*>(ptr)->QPageSetupDialog::event(static_cast<QEvent*>(e));
}
char QPageSetupDialog_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPageSetupDialog*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
char QPageSetupDialog_EventFilterDefault(void* ptr, void* watched, void* event)
{
return static_cast<QPageSetupDialog*>(ptr)->QPageSetupDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
void* QPageSetupDialog_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QPageSetupDialog*>(ptr)->metaObject());
@ -1480,6 +1544,26 @@ void* QPageSetupDialog_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QPageSetupDialog*>(ptr)->QPageSetupDialog::metaObject());
}
int QPageSetupDialog_Metric(void* ptr, long long metric)
{
return static_cast<QPageSetupDialog*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QPageSetupDialog_MetricDefault(void* ptr, long long metric)
{
return static_cast<QPageSetupDialog*>(ptr)->QPageSetupDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QPageSetupDialog_PaintEngine(void* ptr)
{
return static_cast<QPageSetupDialog*>(ptr)->paintEngine();
}
void* QPageSetupDialog_PaintEngineDefault(void* ptr)
{
return static_cast<QPageSetupDialog*>(ptr)->QPageSetupDialog::paintEngine();
}
class MyQPrintDialog: public QPrintDialog
{
public:
@ -1547,7 +1631,11 @@ public:
void customEvent(QEvent * event) { callbackQPrintDialog_CustomEvent(this, event); };
void deleteLater() { callbackQPrintDialog_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQPrintDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQPrintDialog_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQPrintDialog_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPrintDialog_MetaObject(const_cast<MyQPrintDialog*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPrintDialog_Metric(const_cast<MyQPrintDialog*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPrintDialog_PaintEngine(const_cast<MyQPrintDialog*>(this))); };
};
long long QPrintDialog_Options(void* ptr)
@ -2232,6 +2320,26 @@ void QPrintDialog_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QPrintDialog*>(ptr)->QPrintDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QPrintDialog_Event(void* ptr, void* e)
{
return static_cast<QPrintDialog*>(ptr)->event(static_cast<QEvent*>(e));
}
char QPrintDialog_EventDefault(void* ptr, void* e)
{
return static_cast<QPrintDialog*>(ptr)->QPrintDialog::event(static_cast<QEvent*>(e));
}
char QPrintDialog_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPrintDialog*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
char QPrintDialog_EventFilterDefault(void* ptr, void* watched, void* event)
{
return static_cast<QPrintDialog*>(ptr)->QPrintDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
void* QPrintDialog_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QPrintDialog*>(ptr)->metaObject());
@ -2242,6 +2350,26 @@ void* QPrintDialog_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QPrintDialog*>(ptr)->QPrintDialog::metaObject());
}
int QPrintDialog_Metric(void* ptr, long long metric)
{
return static_cast<QPrintDialog*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QPrintDialog_MetricDefault(void* ptr, long long metric)
{
return static_cast<QPrintDialog*>(ptr)->QPrintDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QPrintDialog_PaintEngine(void* ptr)
{
return static_cast<QPrintDialog*>(ptr)->paintEngine();
}
void* QPrintDialog_PaintEngineDefault(void* ptr)
{
return static_cast<QPrintDialog*>(ptr)->QPrintDialog::paintEngine();
}
class MyQPrintEngine: public QPrintEngine
{
public:
@ -2361,7 +2489,11 @@ public:
void customEvent(QEvent * event) { callbackQPrintPreviewDialog_CustomEvent(this, event); };
void deleteLater() { callbackQPrintPreviewDialog_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQPrintPreviewDialog_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQPrintPreviewDialog_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQPrintPreviewDialog_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPrintPreviewDialog_MetaObject(const_cast<MyQPrintPreviewDialog*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPrintPreviewDialog_Metric(const_cast<MyQPrintPreviewDialog*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPrintPreviewDialog_PaintEngine(const_cast<MyQPrintPreviewDialog*>(this))); };
};
void* QPrintPreviewDialog_NewQPrintPreviewDialog2(void* parent, long long flags)
@ -3028,6 +3160,26 @@ void QPrintPreviewDialog_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QPrintPreviewDialog*>(ptr)->QPrintPreviewDialog::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QPrintPreviewDialog_Event(void* ptr, void* e)
{
return static_cast<QPrintPreviewDialog*>(ptr)->event(static_cast<QEvent*>(e));
}
char QPrintPreviewDialog_EventDefault(void* ptr, void* e)
{
return static_cast<QPrintPreviewDialog*>(ptr)->QPrintPreviewDialog::event(static_cast<QEvent*>(e));
}
char QPrintPreviewDialog_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPrintPreviewDialog*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
char QPrintPreviewDialog_EventFilterDefault(void* ptr, void* watched, void* event)
{
return static_cast<QPrintPreviewDialog*>(ptr)->QPrintPreviewDialog::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
void* QPrintPreviewDialog_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QPrintPreviewDialog*>(ptr)->metaObject());
@ -3038,6 +3190,26 @@ void* QPrintPreviewDialog_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QPrintPreviewDialog*>(ptr)->QPrintPreviewDialog::metaObject());
}
int QPrintPreviewDialog_Metric(void* ptr, long long metric)
{
return static_cast<QPrintPreviewDialog*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QPrintPreviewDialog_MetricDefault(void* ptr, long long metric)
{
return static_cast<QPrintPreviewDialog*>(ptr)->QPrintPreviewDialog::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QPrintPreviewDialog_PaintEngine(void* ptr)
{
return static_cast<QPrintPreviewDialog*>(ptr)->paintEngine();
}
void* QPrintPreviewDialog_PaintEngineDefault(void* ptr)
{
return static_cast<QPrintPreviewDialog*>(ptr)->QPrintPreviewDialog::paintEngine();
}
class MyQPrintPreviewWidget: public QPrintPreviewWidget
{
public:
@ -3119,8 +3291,11 @@ public:
void customEvent(QEvent * event) { callbackQPrintPreviewWidget_CustomEvent(this, event); };
void deleteLater() { callbackQPrintPreviewWidget_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQPrintPreviewWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQPrintPreviewWidget_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQPrintPreviewWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQPrintPreviewWidget_MetaObject(const_cast<MyQPrintPreviewWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQPrintPreviewWidget_Metric(const_cast<MyQPrintPreviewWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQPrintPreviewWidget_PaintEngine(const_cast<MyQPrintPreviewWidget*>(this))); };
};
void* QPrintPreviewWidget_NewQPrintPreviewWidget(void* printer, void* parent, long long flags)
@ -3865,6 +4040,16 @@ void QPrintPreviewWidget_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QPrintPreviewWidget*>(ptr)->QPrintPreviewWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QPrintPreviewWidget_Event(void* ptr, void* e)
{
return static_cast<QPrintPreviewWidget*>(ptr)->event(static_cast<QEvent*>(e));
}
char QPrintPreviewWidget_EventDefault(void* ptr, void* e)
{
return static_cast<QPrintPreviewWidget*>(ptr)->QPrintPreviewWidget::event(static_cast<QEvent*>(e));
}
char QPrintPreviewWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QPrintPreviewWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -3885,6 +4070,26 @@ void* QPrintPreviewWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QPrintPreviewWidget*>(ptr)->QPrintPreviewWidget::metaObject());
}
int QPrintPreviewWidget_Metric(void* ptr, long long metric)
{
return static_cast<QPrintPreviewWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QPrintPreviewWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QPrintPreviewWidget*>(ptr)->QPrintPreviewWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QPrintPreviewWidget_PaintEngine(void* ptr)
{
return static_cast<QPrintPreviewWidget*>(ptr)->paintEngine();
}
void* QPrintPreviewWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QPrintPreviewWidget*>(ptr)->QPrintPreviewWidget::paintEngine();
}
int QPrinter_FromPage(void* ptr)
{
return static_cast<QPrinter*>(ptr)->fromPage();

View file

@ -2476,6 +2476,82 @@ func (ptr *QAbstractPrintDialog) DisconnectNotifyDefault(sign core.QMetaMethod_I
}
}
//export callbackQAbstractPrintDialog_Event
func callbackQAbstractPrintDialog_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QAbstractPrintDialog::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQAbstractPrintDialogFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QAbstractPrintDialog) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::event", f)
}
}
func (ptr *QAbstractPrintDialog) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::event")
}
}
func (ptr *QAbstractPrintDialog) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractPrintDialog_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QAbstractPrintDialog) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractPrintDialog_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQAbstractPrintDialog_EventFilter
func callbackQAbstractPrintDialog_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QAbstractPrintDialog::eventFilter"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
return C.char(int8(qt.GoBoolToInt(NewQAbstractPrintDialogFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
func (ptr *QAbstractPrintDialog) ConnectEventFilter(f func(watched *core.QObject, event *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::eventFilter", f)
}
}
func (ptr *QAbstractPrintDialog) DisconnectEventFilter() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::eventFilter")
}
}
func (ptr *QAbstractPrintDialog) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractPrintDialog_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
func (ptr *QAbstractPrintDialog) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QAbstractPrintDialog_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
//export callbackQAbstractPrintDialog_MetaObject
func callbackQAbstractPrintDialog_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
@ -2514,6 +2590,82 @@ func (ptr *QAbstractPrintDialog) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQAbstractPrintDialog_Metric
func callbackQAbstractPrintDialog_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QAbstractPrintDialog::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQAbstractPrintDialogFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QAbstractPrintDialog) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::metric", f)
}
}
func (ptr *QAbstractPrintDialog) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::metric")
}
}
func (ptr *QAbstractPrintDialog) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QAbstractPrintDialog_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QAbstractPrintDialog) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QAbstractPrintDialog_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQAbstractPrintDialog_PaintEngine
func callbackQAbstractPrintDialog_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QAbstractPrintDialog::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQAbstractPrintDialogFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QAbstractPrintDialog) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::paintEngine", f)
}
}
func (ptr *QAbstractPrintDialog) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QAbstractPrintDialog::paintEngine")
}
}
func (ptr *QAbstractPrintDialog) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QAbstractPrintDialog_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QAbstractPrintDialog) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QAbstractPrintDialog_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
type QPageSetupDialog struct {
widgets.QDialog
}
@ -4788,6 +4940,82 @@ func (ptr *QPageSetupDialog) DisconnectNotifyDefault(sign core.QMetaMethod_ITF)
}
}
//export callbackQPageSetupDialog_Event
func callbackQPageSetupDialog_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPageSetupDialog::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQPageSetupDialogFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QPageSetupDialog) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::event", f)
}
}
func (ptr *QPageSetupDialog) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::event")
}
}
func (ptr *QPageSetupDialog) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPageSetupDialog_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QPageSetupDialog) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPageSetupDialog_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQPageSetupDialog_EventFilter
func callbackQPageSetupDialog_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPageSetupDialog::eventFilter"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
return C.char(int8(qt.GoBoolToInt(NewQPageSetupDialogFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
func (ptr *QPageSetupDialog) ConnectEventFilter(f func(watched *core.QObject, event *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::eventFilter", f)
}
}
func (ptr *QPageSetupDialog) DisconnectEventFilter() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::eventFilter")
}
}
func (ptr *QPageSetupDialog) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPageSetupDialog_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
func (ptr *QPageSetupDialog) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPageSetupDialog_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
//export callbackQPageSetupDialog_MetaObject
func callbackQPageSetupDialog_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
@ -4826,6 +5054,82 @@ func (ptr *QPageSetupDialog) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQPageSetupDialog_Metric
func callbackQPageSetupDialog_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPageSetupDialog::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQPageSetupDialogFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QPageSetupDialog) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::metric", f)
}
}
func (ptr *QPageSetupDialog) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::metric")
}
}
func (ptr *QPageSetupDialog) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPageSetupDialog_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QPageSetupDialog) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPageSetupDialog_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQPageSetupDialog_PaintEngine
func callbackQPageSetupDialog_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPageSetupDialog::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQPageSetupDialogFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QPageSetupDialog) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::paintEngine", f)
}
}
func (ptr *QPageSetupDialog) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPageSetupDialog::paintEngine")
}
}
func (ptr *QPageSetupDialog) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPageSetupDialog_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QPageSetupDialog) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPageSetupDialog_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//QPrint::ColorMode
type QPrint__ColorMode int64
@ -7292,6 +7596,82 @@ func (ptr *QPrintDialog) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
}
}
//export callbackQPrintDialog_Event
func callbackQPrintDialog_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintDialog::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQPrintDialogFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QPrintDialog) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::event", f)
}
}
func (ptr *QPrintDialog) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::event")
}
}
func (ptr *QPrintDialog) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintDialog_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QPrintDialog) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintDialog_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQPrintDialog_EventFilter
func callbackQPrintDialog_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintDialog::eventFilter"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
return C.char(int8(qt.GoBoolToInt(NewQPrintDialogFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
func (ptr *QPrintDialog) ConnectEventFilter(f func(watched *core.QObject, event *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::eventFilter", f)
}
}
func (ptr *QPrintDialog) DisconnectEventFilter() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::eventFilter")
}
}
func (ptr *QPrintDialog) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintDialog_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
func (ptr *QPrintDialog) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintDialog_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
//export callbackQPrintDialog_MetaObject
func callbackQPrintDialog_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
@ -7330,6 +7710,82 @@ func (ptr *QPrintDialog) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQPrintDialog_Metric
func callbackQPrintDialog_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintDialog::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQPrintDialogFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QPrintDialog) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::metric", f)
}
}
func (ptr *QPrintDialog) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::metric")
}
}
func (ptr *QPrintDialog) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPrintDialog_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QPrintDialog) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPrintDialog_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQPrintDialog_PaintEngine
func callbackQPrintDialog_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintDialog::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQPrintDialogFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QPrintDialog) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::paintEngine", f)
}
}
func (ptr *QPrintDialog) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintDialog::paintEngine")
}
}
func (ptr *QPrintDialog) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPrintDialog_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QPrintDialog) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPrintDialog_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//QPrintEngine::PrintEnginePropertyKey
type QPrintEngine__PrintEnginePropertyKey int64
@ -9965,6 +10421,82 @@ func (ptr *QPrintPreviewDialog) DisconnectNotifyDefault(sign core.QMetaMethod_IT
}
}
//export callbackQPrintPreviewDialog_Event
func callbackQPrintPreviewDialog_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintPreviewDialog::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQPrintPreviewDialogFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QPrintPreviewDialog) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::event", f)
}
}
func (ptr *QPrintPreviewDialog) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::event")
}
}
func (ptr *QPrintPreviewDialog) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintPreviewDialog_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QPrintPreviewDialog) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintPreviewDialog_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQPrintPreviewDialog_EventFilter
func callbackQPrintPreviewDialog_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintPreviewDialog::eventFilter"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
return C.char(int8(qt.GoBoolToInt(NewQPrintPreviewDialogFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
func (ptr *QPrintPreviewDialog) ConnectEventFilter(f func(watched *core.QObject, event *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::eventFilter", f)
}
}
func (ptr *QPrintPreviewDialog) DisconnectEventFilter() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::eventFilter")
}
}
func (ptr *QPrintPreviewDialog) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintPreviewDialog_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
func (ptr *QPrintPreviewDialog) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintPreviewDialog_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
//export callbackQPrintPreviewDialog_MetaObject
func callbackQPrintPreviewDialog_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
@ -10003,6 +10535,82 @@ func (ptr *QPrintPreviewDialog) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQPrintPreviewDialog_Metric
func callbackQPrintPreviewDialog_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintPreviewDialog::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQPrintPreviewDialogFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QPrintPreviewDialog) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::metric", f)
}
}
func (ptr *QPrintPreviewDialog) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::metric")
}
}
func (ptr *QPrintPreviewDialog) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPrintPreviewDialog_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QPrintPreviewDialog) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPrintPreviewDialog_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQPrintPreviewDialog_PaintEngine
func callbackQPrintPreviewDialog_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintPreviewDialog::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQPrintPreviewDialogFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QPrintPreviewDialog) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::paintEngine", f)
}
}
func (ptr *QPrintPreviewDialog) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewDialog::paintEngine")
}
}
func (ptr *QPrintPreviewDialog) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPrintPreviewDialog_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QPrintPreviewDialog) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPrintPreviewDialog_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//QPrintPreviewWidget::ViewMode
type QPrintPreviewWidget__ViewMode int64
@ -12745,6 +13353,44 @@ func (ptr *QPrintPreviewWidget) DisconnectNotifyDefault(sign core.QMetaMethod_IT
}
}
//export callbackQPrintPreviewWidget_Event
func callbackQPrintPreviewWidget_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintPreviewWidget::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQPrintPreviewWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QPrintPreviewWidget) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewWidget::event", f)
}
}
func (ptr *QPrintPreviewWidget) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewWidget::event")
}
}
func (ptr *QPrintPreviewWidget) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintPreviewWidget_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QPrintPreviewWidget) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QPrintPreviewWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQPrintPreviewWidget_EventFilter
func callbackQPrintPreviewWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -12821,6 +13467,82 @@ func (ptr *QPrintPreviewWidget) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQPrintPreviewWidget_Metric
func callbackQPrintPreviewWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintPreviewWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQPrintPreviewWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QPrintPreviewWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewWidget::metric", f)
}
}
func (ptr *QPrintPreviewWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewWidget::metric")
}
}
func (ptr *QPrintPreviewWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPrintPreviewWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QPrintPreviewWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QPrintPreviewWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQPrintPreviewWidget_PaintEngine
func callbackQPrintPreviewWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QPrintPreviewWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQPrintPreviewWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QPrintPreviewWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewWidget::paintEngine", f)
}
}
func (ptr *QPrintPreviewWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QPrintPreviewWidget::paintEngine")
}
}
func (ptr *QPrintPreviewWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPrintPreviewWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QPrintPreviewWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QPrintPreviewWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//QPrinter::ColorMode
type QPrinter__ColorMode int64

View file

@ -150,8 +150,16 @@ void QAbstractPrintDialog_DeleteLater(void* ptr);
void QAbstractPrintDialog_DeleteLaterDefault(void* ptr);
void QAbstractPrintDialog_DisconnectNotify(void* ptr, void* sign);
void QAbstractPrintDialog_DisconnectNotifyDefault(void* ptr, void* sign);
char QAbstractPrintDialog_Event(void* ptr, void* e);
char QAbstractPrintDialog_EventDefault(void* ptr, void* e);
char QAbstractPrintDialog_EventFilter(void* ptr, void* watched, void* event);
char QAbstractPrintDialog_EventFilterDefault(void* ptr, void* watched, void* event);
void* QAbstractPrintDialog_MetaObject(void* ptr);
void* QAbstractPrintDialog_MetaObjectDefault(void* ptr);
int QAbstractPrintDialog_Metric(void* ptr, long long metric);
int QAbstractPrintDialog_MetricDefault(void* ptr, long long metric);
void* QAbstractPrintDialog_PaintEngine(void* ptr);
void* QAbstractPrintDialog_PaintEngineDefault(void* ptr);
void* QPageSetupDialog_Printer(void* ptr);
void QPageSetupDialog_DestroyQPageSetupDialog(void* ptr);
void QPageSetupDialog_Done(void* ptr, int result);
@ -280,8 +288,16 @@ void QPageSetupDialog_DeleteLater(void* ptr);
void QPageSetupDialog_DeleteLaterDefault(void* ptr);
void QPageSetupDialog_DisconnectNotify(void* ptr, void* sign);
void QPageSetupDialog_DisconnectNotifyDefault(void* ptr, void* sign);
char QPageSetupDialog_Event(void* ptr, void* e);
char QPageSetupDialog_EventDefault(void* ptr, void* e);
char QPageSetupDialog_EventFilter(void* ptr, void* watched, void* event);
char QPageSetupDialog_EventFilterDefault(void* ptr, void* watched, void* event);
void* QPageSetupDialog_MetaObject(void* ptr);
void* QPageSetupDialog_MetaObjectDefault(void* ptr);
int QPageSetupDialog_Metric(void* ptr, long long metric);
int QPageSetupDialog_MetricDefault(void* ptr, long long metric);
void* QPageSetupDialog_PaintEngine(void* ptr);
void* QPageSetupDialog_PaintEngineDefault(void* ptr);
long long QPrintDialog_Options(void* ptr);
void QPrintDialog_SetOptions(void* ptr, long long options);
void QPrintDialog_ConnectAccepted(void* ptr);
@ -418,8 +434,16 @@ void QPrintDialog_DeleteLater(void* ptr);
void QPrintDialog_DeleteLaterDefault(void* ptr);
void QPrintDialog_DisconnectNotify(void* ptr, void* sign);
void QPrintDialog_DisconnectNotifyDefault(void* ptr, void* sign);
char QPrintDialog_Event(void* ptr, void* e);
char QPrintDialog_EventDefault(void* ptr, void* e);
char QPrintDialog_EventFilter(void* ptr, void* watched, void* event);
char QPrintDialog_EventFilterDefault(void* ptr, void* watched, void* event);
void* QPrintDialog_MetaObject(void* ptr);
void* QPrintDialog_MetaObjectDefault(void* ptr);
int QPrintDialog_Metric(void* ptr, long long metric);
int QPrintDialog_MetricDefault(void* ptr, long long metric);
void* QPrintDialog_PaintEngine(void* ptr);
void* QPrintDialog_PaintEngineDefault(void* ptr);
char QPrintEngine_Abort(void* ptr);
int QPrintEngine_Metric(void* ptr, long long id);
char QPrintEngine_NewPage(void* ptr);
@ -560,8 +584,16 @@ void QPrintPreviewDialog_DeleteLater(void* ptr);
void QPrintPreviewDialog_DeleteLaterDefault(void* ptr);
void QPrintPreviewDialog_DisconnectNotify(void* ptr, void* sign);
void QPrintPreviewDialog_DisconnectNotifyDefault(void* ptr, void* sign);
char QPrintPreviewDialog_Event(void* ptr, void* e);
char QPrintPreviewDialog_EventDefault(void* ptr, void* e);
char QPrintPreviewDialog_EventFilter(void* ptr, void* watched, void* event);
char QPrintPreviewDialog_EventFilterDefault(void* ptr, void* watched, void* event);
void* QPrintPreviewDialog_MetaObject(void* ptr);
void* QPrintPreviewDialog_MetaObjectDefault(void* ptr);
int QPrintPreviewDialog_Metric(void* ptr, long long metric);
int QPrintPreviewDialog_MetricDefault(void* ptr, long long metric);
void* QPrintPreviewDialog_PaintEngine(void* ptr);
void* QPrintPreviewDialog_PaintEngineDefault(void* ptr);
void* QPrintPreviewWidget_NewQPrintPreviewWidget(void* printer, void* parent, long long flags);
void* QPrintPreviewWidget_NewQPrintPreviewWidget2(void* parent, long long flags);
int QPrintPreviewWidget_CurrentPage(void* ptr);
@ -710,10 +742,16 @@ void QPrintPreviewWidget_DeleteLater(void* ptr);
void QPrintPreviewWidget_DeleteLaterDefault(void* ptr);
void QPrintPreviewWidget_DisconnectNotify(void* ptr, void* sign);
void QPrintPreviewWidget_DisconnectNotifyDefault(void* ptr, void* sign);
char QPrintPreviewWidget_Event(void* ptr, void* e);
char QPrintPreviewWidget_EventDefault(void* ptr, void* e);
char QPrintPreviewWidget_EventFilter(void* ptr, void* watched, void* event);
char QPrintPreviewWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QPrintPreviewWidget_MetaObject(void* ptr);
void* QPrintPreviewWidget_MetaObjectDefault(void* ptr);
int QPrintPreviewWidget_Metric(void* ptr, long long metric);
int QPrintPreviewWidget_MetricDefault(void* ptr, long long metric);
void* QPrintPreviewWidget_PaintEngine(void* ptr);
void* QPrintPreviewWidget_PaintEngineDefault(void* ptr);
int QPrinter_FromPage(void* ptr);
struct QtPrintSupport_PackedString QPrinter_OutputFileName(void* ptr);
struct QtPrintSupport_PackedString QPrinter_PrinterSelectionOption(void* ptr);

View file

@ -38,6 +38,8 @@
#include <QOpenGLContext>
#include <QOpenGLFramebufferObject>
#include <QOpenGLShader>
#include <QPaintDevice>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPainter>
#include <QPixmap>
@ -110,6 +112,8 @@ public:
QImage requestImage(const QString & id, QSize * size, const QSize & requestedSize) { QByteArray t87ea5d = id.toUtf8(); QtQuick_PackedString idPacked = { const_cast<char*>(t87ea5d.prepend("WHITESPACE").constData()+10), t87ea5d.size()-10 };return *static_cast<QImage*>(callbackQQuickAsyncImageProvider_RequestImage(this, idPacked, size, const_cast<QSize*>(&requestedSize))); };
QPixmap requestPixmap(const QString & id, QSize * size, const QSize & requestedSize) { QByteArray t87ea5d = id.toUtf8(); QtQuick_PackedString idPacked = { const_cast<char*>(t87ea5d.prepend("WHITESPACE").constData()+10), t87ea5d.size()-10 };return *static_cast<QPixmap*>(callbackQQuickAsyncImageProvider_RequestPixmap(this, idPacked, size, const_cast<QSize*>(&requestedSize))); };
QQuickTextureFactory * requestTexture(const QString & id, QSize * size, const QSize & requestedSize) { QByteArray t87ea5d = id.toUtf8(); QtQuick_PackedString idPacked = { const_cast<char*>(t87ea5d.prepend("WHITESPACE").constData()+10), t87ea5d.size()-10 };return static_cast<QQuickTextureFactory*>(callbackQQuickAsyncImageProvider_RequestTexture(this, idPacked, size, const_cast<QSize*>(&requestedSize))); };
Flags flags() const { return static_cast<QQmlImageProviderBase::Flag>(callbackQQuickAsyncImageProvider_Flags(const_cast<MyQQuickAsyncImageProvider*>(this))); };
ImageType imageType() const { return static_cast<QQmlImageProviderBase::ImageType>(callbackQQuickAsyncImageProvider_ImageType(const_cast<MyQQuickAsyncImageProvider*>(this))); };
};
void* QQuickAsyncImageProvider_NewQQuickAsyncImageProvider()
@ -162,6 +166,26 @@ void* QQuickAsyncImageProvider_RequestTextureDefault(void* ptr, char* id, void*
return static_cast<QQuickAsyncImageProvider*>(ptr)->QQuickAsyncImageProvider::requestTexture(QString(id), static_cast<QSize*>(size), *static_cast<QSize*>(requestedSize));
}
long long QQuickAsyncImageProvider_Flags(void* ptr)
{
return static_cast<QQuickAsyncImageProvider*>(ptr)->flags();
}
long long QQuickAsyncImageProvider_FlagsDefault(void* ptr)
{
return static_cast<QQuickAsyncImageProvider*>(ptr)->QQuickAsyncImageProvider::flags();
}
long long QQuickAsyncImageProvider_ImageType(void* ptr)
{
return static_cast<QQuickAsyncImageProvider*>(ptr)->imageType();
}
long long QQuickAsyncImageProvider_ImageTypeDefault(void* ptr)
{
return static_cast<QQuickAsyncImageProvider*>(ptr)->QQuickAsyncImageProvider::imageType();
}
class MyQQuickFramebufferObject: public QQuickFramebufferObject
{
public:
@ -202,8 +226,11 @@ public:
void customEvent(QEvent * event) { callbackQQuickFramebufferObject_CustomEvent(this, event); };
void deleteLater() { callbackQQuickFramebufferObject_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQQuickFramebufferObject_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQQuickFramebufferObject_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQQuickFramebufferObject_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQQuickFramebufferObject_MetaObject(const_cast<MyQQuickFramebufferObject*>(this))); };
void classBegin() { callbackQQuickFramebufferObject_ClassBegin(this); };
void componentComplete() { callbackQQuickFramebufferObject_ComponentComplete(this); };
};
char QQuickFramebufferObject_MirrorVertically(void* ptr)
@ -606,6 +633,16 @@ void QQuickFramebufferObject_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QQuickFramebufferObject*>(ptr)->QQuickFramebufferObject::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QQuickFramebufferObject_Event(void* ptr, void* e)
{
return static_cast<QQuickFramebufferObject*>(ptr)->event(static_cast<QEvent*>(e));
}
char QQuickFramebufferObject_EventDefault(void* ptr, void* e)
{
return static_cast<QQuickFramebufferObject*>(ptr)->QQuickFramebufferObject::event(static_cast<QEvent*>(e));
}
char QQuickFramebufferObject_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QQuickFramebufferObject*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -626,6 +663,26 @@ void* QQuickFramebufferObject_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QQuickFramebufferObject*>(ptr)->QQuickFramebufferObject::metaObject());
}
void QQuickFramebufferObject_ClassBegin(void* ptr)
{
static_cast<QQuickFramebufferObject*>(ptr)->classBegin();
}
void QQuickFramebufferObject_ClassBeginDefault(void* ptr)
{
static_cast<QQuickFramebufferObject*>(ptr)->QQuickFramebufferObject::classBegin();
}
void QQuickFramebufferObject_ComponentComplete(void* ptr)
{
static_cast<QQuickFramebufferObject*>(ptr)->componentComplete();
}
void QQuickFramebufferObject_ComponentCompleteDefault(void* ptr)
{
static_cast<QQuickFramebufferObject*>(ptr)->QQuickFramebufferObject::componentComplete();
}
class MyQQuickImageProvider: public QQuickImageProvider
{
public:
@ -1961,8 +2018,11 @@ public:
void customEvent(QEvent * event) { callbackQQuickPaintedItem_CustomEvent(this, event); };
void deleteLater() { callbackQQuickPaintedItem_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQQuickPaintedItem_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQQuickPaintedItem_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQQuickPaintedItem_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQQuickPaintedItem_MetaObject(const_cast<MyQQuickPaintedItem*>(this))); };
void classBegin() { callbackQQuickPaintedItem_ClassBegin(this); };
void componentComplete() { callbackQQuickPaintedItem_ComponentComplete(this); };
};
double QQuickPaintedItem_ContentsScale(void* ptr)
@ -2500,6 +2560,16 @@ void QQuickPaintedItem_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QQuickPaintedItem*>(ptr)->QQuickPaintedItem::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QQuickPaintedItem_Event(void* ptr, void* e)
{
return static_cast<QQuickPaintedItem*>(ptr)->event(static_cast<QEvent*>(e));
}
char QQuickPaintedItem_EventDefault(void* ptr, void* e)
{
return static_cast<QQuickPaintedItem*>(ptr)->QQuickPaintedItem::event(static_cast<QEvent*>(e));
}
char QQuickPaintedItem_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QQuickPaintedItem*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -2520,6 +2590,26 @@ void* QQuickPaintedItem_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QQuickPaintedItem*>(ptr)->QQuickPaintedItem::metaObject());
}
void QQuickPaintedItem_ClassBegin(void* ptr)
{
static_cast<QQuickPaintedItem*>(ptr)->classBegin();
}
void QQuickPaintedItem_ClassBeginDefault(void* ptr)
{
static_cast<QQuickPaintedItem*>(ptr)->QQuickPaintedItem::classBegin();
}
void QQuickPaintedItem_ComponentComplete(void* ptr)
{
static_cast<QQuickPaintedItem*>(ptr)->componentComplete();
}
void QQuickPaintedItem_ComponentCompleteDefault(void* ptr)
{
static_cast<QQuickPaintedItem*>(ptr)->QQuickPaintedItem::componentComplete();
}
class MyQQuickRenderControl: public QQuickRenderControl
{
public:
@ -2996,16 +3086,24 @@ public:
void setY(int arg) { callbackQQuickView_SetY(this, arg); };
void alert(int msec) { callbackQQuickView_Alert(this, msec); };
bool close() { return callbackQQuickView_Close(this) != 0; };
bool event(QEvent * ev) { return callbackQQuickView_Event(this, ev) != 0; };
void exposeEvent(QExposeEvent * ev) { callbackQQuickView_ExposeEvent(this, ev); };
void focusInEvent(QFocusEvent * ev) { callbackQQuickView_FocusInEvent(this, ev); };
QObject * focusObject() const { return static_cast<QObject*>(callbackQQuickView_FocusObject(const_cast<MyQQuickView*>(this))); };
void focusOutEvent(QFocusEvent * ev) { callbackQQuickView_FocusOutEvent(this, ev); };
QSurfaceFormat format() const { return *static_cast<QSurfaceFormat*>(callbackQQuickView_Format(const_cast<MyQQuickView*>(this))); };
void hide() { callbackQQuickView_Hide(this); };
void hideEvent(QHideEvent * ev) { callbackQQuickView_HideEvent(this, ev); };
void lower() { callbackQQuickView_Lower(this); };
void mouseDoubleClickEvent(QMouseEvent * ev) { callbackQQuickView_MouseDoubleClickEvent(this, ev); };
void moveEvent(QMoveEvent * ev) { callbackQQuickView_MoveEvent(this, ev); };
bool nativeEvent(const QByteArray & eventType, void * message, long * result) { return callbackQQuickView_NativeEvent(this, const_cast<QByteArray*>(&eventType), message, *result) != 0; };
void raise() { callbackQQuickView_Raise(this); };
void requestActivate() { callbackQQuickView_RequestActivate(this); };
void requestUpdate() { callbackQQuickView_RequestUpdate(this); };
void resizeEvent(QResizeEvent * ev) { callbackQQuickView_ResizeEvent(this, ev); };
void show() { callbackQQuickView_Show(this); };
void showEvent(QShowEvent * ev) { callbackQQuickView_ShowEvent(this, ev); };
void showFullScreen() { callbackQQuickView_ShowFullScreen(this); };
void showMaximized() { callbackQQuickView_ShowMaximized(this); };
void showMinimized() { callbackQQuickView_ShowMinimized(this); };
@ -3014,6 +3112,7 @@ public:
SurfaceType surfaceType() const { return static_cast<QSurface::SurfaceType>(callbackQQuickView_SurfaceType(const_cast<MyQQuickView*>(this))); };
void tabletEvent(QTabletEvent * ev) { callbackQQuickView_TabletEvent(this, ev); };
void touchEvent(QTouchEvent * ev) { callbackQQuickView_TouchEvent(this, ev); };
void wheelEvent(QWheelEvent * ev) { callbackQQuickView_WheelEvent(this, ev); };
void timerEvent(QTimerEvent * event) { callbackQQuickView_TimerEvent(this, event); };
void childEvent(QChildEvent * event) { callbackQQuickView_ChildEvent(this, event); };
void connectNotify(const QMetaMethod & sign) { callbackQQuickView_ConnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
@ -3286,6 +3385,36 @@ char QQuickView_CloseDefault(void* ptr)
return static_cast<QQuickView*>(ptr)->QQuickView::close();
}
char QQuickView_Event(void* ptr, void* ev)
{
return static_cast<QQuickView*>(ptr)->event(static_cast<QEvent*>(ev));
}
char QQuickView_EventDefault(void* ptr, void* ev)
{
return static_cast<QQuickView*>(ptr)->QQuickView::event(static_cast<QEvent*>(ev));
}
void QQuickView_ExposeEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->exposeEvent(static_cast<QExposeEvent*>(ev));
}
void QQuickView_ExposeEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::exposeEvent(static_cast<QExposeEvent*>(ev));
}
void QQuickView_FocusInEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->focusInEvent(static_cast<QFocusEvent*>(ev));
}
void QQuickView_FocusInEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::focusInEvent(static_cast<QFocusEvent*>(ev));
}
void* QQuickView_FocusObject(void* ptr)
{
return static_cast<QQuickView*>(ptr)->focusObject();
@ -3296,6 +3425,16 @@ void* QQuickView_FocusObjectDefault(void* ptr)
return static_cast<QQuickView*>(ptr)->QQuickView::focusObject();
}
void QQuickView_FocusOutEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->focusOutEvent(static_cast<QFocusEvent*>(ev));
}
void QQuickView_FocusOutEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::focusOutEvent(static_cast<QFocusEvent*>(ev));
}
void* QQuickView_Format(void* ptr)
{
return new QSurfaceFormat(static_cast<QQuickView*>(ptr)->format());
@ -3316,6 +3455,16 @@ void QQuickView_HideDefault(void* ptr)
static_cast<QQuickView*>(ptr)->QQuickView::hide();
}
void QQuickView_HideEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->hideEvent(static_cast<QHideEvent*>(ev));
}
void QQuickView_HideEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::hideEvent(static_cast<QHideEvent*>(ev));
}
void QQuickView_Lower(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QQuickView*>(ptr), "lower");
@ -3326,6 +3475,16 @@ void QQuickView_LowerDefault(void* ptr)
static_cast<QQuickView*>(ptr)->QQuickView::lower();
}
void QQuickView_MouseDoubleClickEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
}
void QQuickView_MouseDoubleClickEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::mouseDoubleClickEvent(static_cast<QMouseEvent*>(ev));
}
void QQuickView_MoveEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->moveEvent(static_cast<QMoveEvent*>(ev));
@ -3376,6 +3535,16 @@ void QQuickView_RequestUpdateDefault(void* ptr)
static_cast<QQuickView*>(ptr)->QQuickView::requestUpdate();
}
void QQuickView_ResizeEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->resizeEvent(static_cast<QResizeEvent*>(ev));
}
void QQuickView_ResizeEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::resizeEvent(static_cast<QResizeEvent*>(ev));
}
void QQuickView_Show(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QQuickView*>(ptr), "show");
@ -3386,6 +3555,16 @@ void QQuickView_ShowDefault(void* ptr)
static_cast<QQuickView*>(ptr)->QQuickView::show();
}
void QQuickView_ShowEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->showEvent(static_cast<QShowEvent*>(ev));
}
void QQuickView_ShowEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::showEvent(static_cast<QShowEvent*>(ev));
}
void QQuickView_ShowFullScreen(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QQuickView*>(ptr), "showFullScreen");
@ -3466,6 +3645,16 @@ void QQuickView_TouchEventDefault(void* ptr, void* ev)
static_cast<QQuickView*>(ptr)->QQuickView::touchEvent(static_cast<QTouchEvent*>(ev));
}
void QQuickView_WheelEvent(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->wheelEvent(static_cast<QWheelEvent*>(ev));
}
void QQuickView_WheelEventDefault(void* ptr, void* ev)
{
static_cast<QQuickView*>(ptr)->QQuickView::wheelEvent(static_cast<QWheelEvent*>(ev));
}
void QQuickView_TimerEvent(void* ptr, void* event)
{
static_cast<QQuickView*>(ptr)->timerEvent(static_cast<QTimerEvent*>(event));
@ -3617,6 +3806,8 @@ public:
void disconnectNotify(const QMetaMethod & sign) { callbackQQuickWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQQuickWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQQuickWidget_MetaObject(const_cast<MyQQuickWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQQuickWidget_Metric(const_cast<MyQQuickWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQQuickWidget_PaintEngine(const_cast<MyQQuickWidget*>(this))); };
};
long long QQuickWidget_ResizeMode(void* ptr)
@ -4371,6 +4562,26 @@ void* QQuickWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QQuickWidget*>(ptr)->QQuickWidget::metaObject());
}
int QQuickWidget_Metric(void* ptr, long long metric)
{
return static_cast<QQuickWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QQuickWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QQuickWidget*>(ptr)->QQuickWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QQuickWidget_PaintEngine(void* ptr)
{
return static_cast<QQuickWidget*>(ptr)->paintEngine();
}
void* QQuickWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QQuickWidget*>(ptr)->QQuickWidget::paintEngine();
}
class MyQQuickWindow: public QQuickWindow
{
public:

View file

@ -286,6 +286,82 @@ func (ptr *QQuickAsyncImageProvider) RequestTextureDefault(id string, size core.
return nil
}
//export callbackQQuickAsyncImageProvider_Flags
func callbackQQuickAsyncImageProvider_Flags(ptr unsafe.Pointer) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickAsyncImageProvider::flags"); signal != nil {
return C.longlong(signal.(func() qml.QQmlImageProviderBase__Flag)())
}
return C.longlong(NewQQuickAsyncImageProviderFromPointer(ptr).FlagsDefault())
}
func (ptr *QQuickAsyncImageProvider) ConnectFlags(f func() qml.QQmlImageProviderBase__Flag) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickAsyncImageProvider::flags", f)
}
}
func (ptr *QQuickAsyncImageProvider) DisconnectFlags() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickAsyncImageProvider::flags")
}
}
func (ptr *QQuickAsyncImageProvider) Flags() qml.QQmlImageProviderBase__Flag {
if ptr.Pointer() != nil {
return qml.QQmlImageProviderBase__Flag(C.QQuickAsyncImageProvider_Flags(ptr.Pointer()))
}
return 0
}
func (ptr *QQuickAsyncImageProvider) FlagsDefault() qml.QQmlImageProviderBase__Flag {
if ptr.Pointer() != nil {
return qml.QQmlImageProviderBase__Flag(C.QQuickAsyncImageProvider_FlagsDefault(ptr.Pointer()))
}
return 0
}
//export callbackQQuickAsyncImageProvider_ImageType
func callbackQQuickAsyncImageProvider_ImageType(ptr unsafe.Pointer) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickAsyncImageProvider::imageType"); signal != nil {
return C.longlong(signal.(func() qml.QQmlImageProviderBase__ImageType)())
}
return C.longlong(NewQQuickAsyncImageProviderFromPointer(ptr).ImageTypeDefault())
}
func (ptr *QQuickAsyncImageProvider) ConnectImageType(f func() qml.QQmlImageProviderBase__ImageType) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickAsyncImageProvider::imageType", f)
}
}
func (ptr *QQuickAsyncImageProvider) DisconnectImageType() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickAsyncImageProvider::imageType")
}
}
func (ptr *QQuickAsyncImageProvider) ImageType() qml.QQmlImageProviderBase__ImageType {
if ptr.Pointer() != nil {
return qml.QQmlImageProviderBase__ImageType(C.QQuickAsyncImageProvider_ImageType(ptr.Pointer()))
}
return 0
}
func (ptr *QQuickAsyncImageProvider) ImageTypeDefault() qml.QQmlImageProviderBase__ImageType {
if ptr.Pointer() != nil {
return qml.QQmlImageProviderBase__ImageType(C.QQuickAsyncImageProvider_ImageTypeDefault(ptr.Pointer()))
}
return 0
}
type QQuickFramebufferObject struct {
QQuickItem
}
@ -1699,6 +1775,44 @@ func (ptr *QQuickFramebufferObject) DisconnectNotifyDefault(sign core.QMetaMetho
}
}
//export callbackQQuickFramebufferObject_Event
func callbackQQuickFramebufferObject_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickFramebufferObject::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQQuickFramebufferObjectFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QQuickFramebufferObject) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickFramebufferObject::event", f)
}
}
func (ptr *QQuickFramebufferObject) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickFramebufferObject::event")
}
}
func (ptr *QQuickFramebufferObject) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QQuickFramebufferObject_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QQuickFramebufferObject) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QQuickFramebufferObject_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQQuickFramebufferObject_EventFilter
func callbackQQuickFramebufferObject_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -1775,6 +1889,78 @@ func (ptr *QQuickFramebufferObject) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQQuickFramebufferObject_ClassBegin
func callbackQQuickFramebufferObject_ClassBegin(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickFramebufferObject::classBegin"); signal != nil {
signal.(func())()
} else {
NewQQuickFramebufferObjectFromPointer(ptr).ClassBeginDefault()
}
}
func (ptr *QQuickFramebufferObject) ConnectClassBegin(f func()) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickFramebufferObject::classBegin", f)
}
}
func (ptr *QQuickFramebufferObject) DisconnectClassBegin() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickFramebufferObject::classBegin")
}
}
func (ptr *QQuickFramebufferObject) ClassBegin() {
if ptr.Pointer() != nil {
C.QQuickFramebufferObject_ClassBegin(ptr.Pointer())
}
}
func (ptr *QQuickFramebufferObject) ClassBeginDefault() {
if ptr.Pointer() != nil {
C.QQuickFramebufferObject_ClassBeginDefault(ptr.Pointer())
}
}
//export callbackQQuickFramebufferObject_ComponentComplete
func callbackQQuickFramebufferObject_ComponentComplete(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickFramebufferObject::componentComplete"); signal != nil {
signal.(func())()
} else {
NewQQuickFramebufferObjectFromPointer(ptr).ComponentCompleteDefault()
}
}
func (ptr *QQuickFramebufferObject) ConnectComponentComplete(f func()) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickFramebufferObject::componentComplete", f)
}
}
func (ptr *QQuickFramebufferObject) DisconnectComponentComplete() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickFramebufferObject::componentComplete")
}
}
func (ptr *QQuickFramebufferObject) ComponentComplete() {
if ptr.Pointer() != nil {
C.QQuickFramebufferObject_ComponentComplete(ptr.Pointer())
}
}
func (ptr *QQuickFramebufferObject) ComponentCompleteDefault() {
if ptr.Pointer() != nil {
C.QQuickFramebufferObject_ComponentCompleteDefault(ptr.Pointer())
}
}
type QQuickImageProvider struct {
qml.QQmlImageProviderBase
}
@ -6866,6 +7052,44 @@ func (ptr *QQuickPaintedItem) DisconnectNotifyDefault(sign core.QMetaMethod_ITF)
}
}
//export callbackQQuickPaintedItem_Event
func callbackQQuickPaintedItem_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickPaintedItem::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQQuickPaintedItemFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QQuickPaintedItem) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickPaintedItem::event", f)
}
}
func (ptr *QQuickPaintedItem) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickPaintedItem::event")
}
}
func (ptr *QQuickPaintedItem) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QQuickPaintedItem_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QQuickPaintedItem) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QQuickPaintedItem_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQQuickPaintedItem_EventFilter
func callbackQQuickPaintedItem_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -6942,6 +7166,78 @@ func (ptr *QQuickPaintedItem) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQQuickPaintedItem_ClassBegin
func callbackQQuickPaintedItem_ClassBegin(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickPaintedItem::classBegin"); signal != nil {
signal.(func())()
} else {
NewQQuickPaintedItemFromPointer(ptr).ClassBeginDefault()
}
}
func (ptr *QQuickPaintedItem) ConnectClassBegin(f func()) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickPaintedItem::classBegin", f)
}
}
func (ptr *QQuickPaintedItem) DisconnectClassBegin() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickPaintedItem::classBegin")
}
}
func (ptr *QQuickPaintedItem) ClassBegin() {
if ptr.Pointer() != nil {
C.QQuickPaintedItem_ClassBegin(ptr.Pointer())
}
}
func (ptr *QQuickPaintedItem) ClassBeginDefault() {
if ptr.Pointer() != nil {
C.QQuickPaintedItem_ClassBeginDefault(ptr.Pointer())
}
}
//export callbackQQuickPaintedItem_ComponentComplete
func callbackQQuickPaintedItem_ComponentComplete(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickPaintedItem::componentComplete"); signal != nil {
signal.(func())()
} else {
NewQQuickPaintedItemFromPointer(ptr).ComponentCompleteDefault()
}
}
func (ptr *QQuickPaintedItem) ConnectComponentComplete(f func()) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickPaintedItem::componentComplete", f)
}
}
func (ptr *QQuickPaintedItem) DisconnectComponentComplete() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickPaintedItem::componentComplete")
}
}
func (ptr *QQuickPaintedItem) ComponentComplete() {
if ptr.Pointer() != nil {
C.QQuickPaintedItem_ComponentComplete(ptr.Pointer())
}
}
func (ptr *QQuickPaintedItem) ComponentCompleteDefault() {
if ptr.Pointer() != nil {
C.QQuickPaintedItem_ComponentCompleteDefault(ptr.Pointer())
}
}
type QQuickRenderControl struct {
core.QObject
}
@ -9265,6 +9561,116 @@ func (ptr *QQuickView) CloseDefault() bool {
return false
}
//export callbackQQuickView_Event
func callbackQQuickView_Event(ptr unsafe.Pointer, ev unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(ev)))))
}
return C.char(int8(qt.GoBoolToInt(NewQQuickViewFromPointer(ptr).EventDefault(core.NewQEventFromPointer(ev)))))
}
func (ptr *QQuickView) ConnectEvent(f func(ev *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::event", f)
}
}
func (ptr *QQuickView) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::event")
}
}
func (ptr *QQuickView) Event(ev core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QQuickView_Event(ptr.Pointer(), core.PointerFromQEvent(ev)) != 0
}
return false
}
func (ptr *QQuickView) EventDefault(ev core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QQuickView_EventDefault(ptr.Pointer(), core.PointerFromQEvent(ev)) != 0
}
return false
}
//export callbackQQuickView_ExposeEvent
func callbackQQuickView_ExposeEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::exposeEvent"); signal != nil {
signal.(func(*gui.QExposeEvent))(gui.NewQExposeEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).ExposeEventDefault(gui.NewQExposeEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectExposeEvent(f func(ev *gui.QExposeEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::exposeEvent", f)
}
}
func (ptr *QQuickView) DisconnectExposeEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::exposeEvent")
}
}
func (ptr *QQuickView) ExposeEvent(ev gui.QExposeEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_ExposeEvent(ptr.Pointer(), gui.PointerFromQExposeEvent(ev))
}
}
func (ptr *QQuickView) ExposeEventDefault(ev gui.QExposeEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_ExposeEventDefault(ptr.Pointer(), gui.PointerFromQExposeEvent(ev))
}
}
//export callbackQQuickView_FocusInEvent
func callbackQQuickView_FocusInEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::focusInEvent"); signal != nil {
signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectFocusInEvent(f func(ev *gui.QFocusEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::focusInEvent", f)
}
}
func (ptr *QQuickView) DisconnectFocusInEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::focusInEvent")
}
}
func (ptr *QQuickView) FocusInEvent(ev gui.QFocusEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_FocusInEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(ev))
}
}
func (ptr *QQuickView) FocusInEventDefault(ev gui.QFocusEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(ev))
}
}
//export callbackQQuickView_FocusObject
func callbackQQuickView_FocusObject(ptr unsafe.Pointer) unsafe.Pointer {
@ -9311,6 +9717,42 @@ func (ptr *QQuickView) FocusObjectDefault() *core.QObject {
return nil
}
//export callbackQQuickView_FocusOutEvent
func callbackQQuickView_FocusOutEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::focusOutEvent"); signal != nil {
signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectFocusOutEvent(f func(ev *gui.QFocusEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::focusOutEvent", f)
}
}
func (ptr *QQuickView) DisconnectFocusOutEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::focusOutEvent")
}
}
func (ptr *QQuickView) FocusOutEvent(ev gui.QFocusEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_FocusOutEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(ev))
}
}
func (ptr *QQuickView) FocusOutEventDefault(ev gui.QFocusEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(ev))
}
}
//export callbackQQuickView_Format
func callbackQQuickView_Format(ptr unsafe.Pointer) unsafe.Pointer {
@ -9388,6 +9830,42 @@ func (ptr *QQuickView) HideDefault() {
}
}
//export callbackQQuickView_HideEvent
func callbackQQuickView_HideEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::hideEvent"); signal != nil {
signal.(func(*gui.QHideEvent))(gui.NewQHideEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).HideEventDefault(gui.NewQHideEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectHideEvent(f func(ev *gui.QHideEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::hideEvent", f)
}
}
func (ptr *QQuickView) DisconnectHideEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::hideEvent")
}
}
func (ptr *QQuickView) HideEvent(ev gui.QHideEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_HideEvent(ptr.Pointer(), gui.PointerFromQHideEvent(ev))
}
}
func (ptr *QQuickView) HideEventDefault(ev gui.QHideEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_HideEventDefault(ptr.Pointer(), gui.PointerFromQHideEvent(ev))
}
}
//export callbackQQuickView_Lower
func callbackQQuickView_Lower(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::lower"); signal != nil {
@ -9423,6 +9901,42 @@ func (ptr *QQuickView) LowerDefault() {
}
}
//export callbackQQuickView_MouseDoubleClickEvent
func callbackQQuickView_MouseDoubleClickEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::mouseDoubleClickEvent"); signal != nil {
signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).MouseDoubleClickEventDefault(gui.NewQMouseEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectMouseDoubleClickEvent(f func(ev *gui.QMouseEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::mouseDoubleClickEvent", f)
}
}
func (ptr *QQuickView) DisconnectMouseDoubleClickEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::mouseDoubleClickEvent")
}
}
func (ptr *QQuickView) MouseDoubleClickEvent(ev gui.QMouseEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_MouseDoubleClickEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(ev))
}
}
func (ptr *QQuickView) MouseDoubleClickEventDefault(ev gui.QMouseEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_MouseDoubleClickEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(ev))
}
}
//export callbackQQuickView_MoveEvent
func callbackQQuickView_MoveEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
@ -9602,6 +10116,42 @@ func (ptr *QQuickView) RequestUpdateDefault() {
}
}
//export callbackQQuickView_ResizeEvent
func callbackQQuickView_ResizeEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::resizeEvent"); signal != nil {
signal.(func(*gui.QResizeEvent))(gui.NewQResizeEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).ResizeEventDefault(gui.NewQResizeEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectResizeEvent(f func(ev *gui.QResizeEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::resizeEvent", f)
}
}
func (ptr *QQuickView) DisconnectResizeEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::resizeEvent")
}
}
func (ptr *QQuickView) ResizeEvent(ev gui.QResizeEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_ResizeEvent(ptr.Pointer(), gui.PointerFromQResizeEvent(ev))
}
}
func (ptr *QQuickView) ResizeEventDefault(ev gui.QResizeEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_ResizeEventDefault(ptr.Pointer(), gui.PointerFromQResizeEvent(ev))
}
}
//export callbackQQuickView_Show
func callbackQQuickView_Show(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::show"); signal != nil {
@ -9637,6 +10187,42 @@ func (ptr *QQuickView) ShowDefault() {
}
}
//export callbackQQuickView_ShowEvent
func callbackQQuickView_ShowEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::showEvent"); signal != nil {
signal.(func(*gui.QShowEvent))(gui.NewQShowEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).ShowEventDefault(gui.NewQShowEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectShowEvent(f func(ev *gui.QShowEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::showEvent", f)
}
}
func (ptr *QQuickView) DisconnectShowEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::showEvent")
}
}
func (ptr *QQuickView) ShowEvent(ev gui.QShowEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_ShowEvent(ptr.Pointer(), gui.PointerFromQShowEvent(ev))
}
}
func (ptr *QQuickView) ShowEventDefault(ev gui.QShowEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_ShowEventDefault(ptr.Pointer(), gui.PointerFromQShowEvent(ev))
}
}
//export callbackQQuickView_ShowFullScreen
func callbackQQuickView_ShowFullScreen(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::showFullScreen"); signal != nil {
@ -9929,6 +10515,42 @@ func (ptr *QQuickView) TouchEventDefault(ev gui.QTouchEvent_ITF) {
}
}
//export callbackQQuickView_WheelEvent
func callbackQQuickView_WheelEvent(ptr unsafe.Pointer, ev unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickView::wheelEvent"); signal != nil {
signal.(func(*gui.QWheelEvent))(gui.NewQWheelEventFromPointer(ev))
} else {
NewQQuickViewFromPointer(ptr).WheelEventDefault(gui.NewQWheelEventFromPointer(ev))
}
}
func (ptr *QQuickView) ConnectWheelEvent(f func(ev *gui.QWheelEvent)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::wheelEvent", f)
}
}
func (ptr *QQuickView) DisconnectWheelEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickView::wheelEvent")
}
}
func (ptr *QQuickView) WheelEvent(ev gui.QWheelEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_WheelEvent(ptr.Pointer(), gui.PointerFromQWheelEvent(ev))
}
}
func (ptr *QQuickView) WheelEventDefault(ev gui.QWheelEvent_ITF) {
if ptr.Pointer() != nil {
C.QQuickView_WheelEventDefault(ptr.Pointer(), gui.PointerFromQWheelEvent(ev))
}
}
//export callbackQQuickView_TimerEvent
func callbackQQuickView_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
@ -12792,6 +13414,82 @@ func (ptr *QQuickWidget) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQQuickWidget_Metric
func callbackQQuickWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQQuickWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QQuickWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickWidget::metric", f)
}
}
func (ptr *QQuickWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickWidget::metric")
}
}
func (ptr *QQuickWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QQuickWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QQuickWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QQuickWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQQuickWidget_PaintEngine
func callbackQQuickWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QQuickWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQQuickWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QQuickWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickWidget::paintEngine", f)
}
}
func (ptr *QQuickWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QQuickWidget::paintEngine")
}
}
func (ptr *QQuickWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QQuickWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QQuickWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QQuickWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//QQuickWindow::CreateTextureOption
type QQuickWindow__CreateTextureOption int64

View file

@ -23,6 +23,10 @@ void* QQuickAsyncImageProvider_RequestPixmap(void* ptr, char* id, void* size, vo
void* QQuickAsyncImageProvider_RequestPixmapDefault(void* ptr, char* id, void* size, void* requestedSize);
void* QQuickAsyncImageProvider_RequestTexture(void* ptr, char* id, void* size, void* requestedSize);
void* QQuickAsyncImageProvider_RequestTextureDefault(void* ptr, char* id, void* size, void* requestedSize);
long long QQuickAsyncImageProvider_Flags(void* ptr);
long long QQuickAsyncImageProvider_FlagsDefault(void* ptr);
long long QQuickAsyncImageProvider_ImageType(void* ptr);
long long QQuickAsyncImageProvider_ImageTypeDefault(void* ptr);
char QQuickFramebufferObject_MirrorVertically(void* ptr);
void QQuickFramebufferObject_SetMirrorVertically(void* ptr, char enable);
void QQuickFramebufferObject_SetTextureFollowsItemSize(void* ptr, char follows);
@ -103,10 +107,16 @@ void QQuickFramebufferObject_DeleteLater(void* ptr);
void QQuickFramebufferObject_DeleteLaterDefault(void* ptr);
void QQuickFramebufferObject_DisconnectNotify(void* ptr, void* sign);
void QQuickFramebufferObject_DisconnectNotifyDefault(void* ptr, void* sign);
char QQuickFramebufferObject_Event(void* ptr, void* e);
char QQuickFramebufferObject_EventDefault(void* ptr, void* e);
char QQuickFramebufferObject_EventFilter(void* ptr, void* watched, void* event);
char QQuickFramebufferObject_EventFilterDefault(void* ptr, void* watched, void* event);
void* QQuickFramebufferObject_MetaObject(void* ptr);
void* QQuickFramebufferObject_MetaObjectDefault(void* ptr);
void QQuickFramebufferObject_ClassBegin(void* ptr);
void QQuickFramebufferObject_ClassBeginDefault(void* ptr);
void QQuickFramebufferObject_ComponentComplete(void* ptr);
void QQuickFramebufferObject_ComponentCompleteDefault(void* ptr);
void* QQuickImageProvider_NewQQuickImageProvider(long long ty, long long flags);
long long QQuickImageProvider_Flags(void* ptr);
long long QQuickImageProvider_ImageType(void* ptr);
@ -454,10 +464,16 @@ void QQuickPaintedItem_DeleteLater(void* ptr);
void QQuickPaintedItem_DeleteLaterDefault(void* ptr);
void QQuickPaintedItem_DisconnectNotify(void* ptr, void* sign);
void QQuickPaintedItem_DisconnectNotifyDefault(void* ptr, void* sign);
char QQuickPaintedItem_Event(void* ptr, void* e);
char QQuickPaintedItem_EventDefault(void* ptr, void* e);
char QQuickPaintedItem_EventFilter(void* ptr, void* watched, void* event);
char QQuickPaintedItem_EventFilterDefault(void* ptr, void* watched, void* event);
void* QQuickPaintedItem_MetaObject(void* ptr);
void* QQuickPaintedItem_MetaObjectDefault(void* ptr);
void QQuickPaintedItem_ClassBegin(void* ptr);
void QQuickPaintedItem_ClassBeginDefault(void* ptr);
void QQuickPaintedItem_ComponentComplete(void* ptr);
void QQuickPaintedItem_ComponentCompleteDefault(void* ptr);
void* QQuickRenderControl_NewQQuickRenderControl(void* parent);
void* QQuickRenderControl_Grab(void* ptr);
void QQuickRenderControl_Initialize(void* ptr, void* gl);
@ -593,14 +609,26 @@ void QQuickView_Alert(void* ptr, int msec);
void QQuickView_AlertDefault(void* ptr, int msec);
char QQuickView_Close(void* ptr);
char QQuickView_CloseDefault(void* ptr);
char QQuickView_Event(void* ptr, void* ev);
char QQuickView_EventDefault(void* ptr, void* ev);
void QQuickView_ExposeEvent(void* ptr, void* ev);
void QQuickView_ExposeEventDefault(void* ptr, void* ev);
void QQuickView_FocusInEvent(void* ptr, void* ev);
void QQuickView_FocusInEventDefault(void* ptr, void* ev);
void* QQuickView_FocusObject(void* ptr);
void* QQuickView_FocusObjectDefault(void* ptr);
void QQuickView_FocusOutEvent(void* ptr, void* ev);
void QQuickView_FocusOutEventDefault(void* ptr, void* ev);
void* QQuickView_Format(void* ptr);
void* QQuickView_FormatDefault(void* ptr);
void QQuickView_Hide(void* ptr);
void QQuickView_HideDefault(void* ptr);
void QQuickView_HideEvent(void* ptr, void* ev);
void QQuickView_HideEventDefault(void* ptr, void* ev);
void QQuickView_Lower(void* ptr);
void QQuickView_LowerDefault(void* ptr);
void QQuickView_MouseDoubleClickEvent(void* ptr, void* ev);
void QQuickView_MouseDoubleClickEventDefault(void* ptr, void* ev);
void QQuickView_MoveEvent(void* ptr, void* ev);
void QQuickView_MoveEventDefault(void* ptr, void* ev);
char QQuickView_NativeEvent(void* ptr, void* eventType, void* message, long result);
@ -611,8 +639,12 @@ void QQuickView_RequestActivate(void* ptr);
void QQuickView_RequestActivateDefault(void* ptr);
void QQuickView_RequestUpdate(void* ptr);
void QQuickView_RequestUpdateDefault(void* ptr);
void QQuickView_ResizeEvent(void* ptr, void* ev);
void QQuickView_ResizeEventDefault(void* ptr, void* ev);
void QQuickView_Show(void* ptr);
void QQuickView_ShowDefault(void* ptr);
void QQuickView_ShowEvent(void* ptr, void* ev);
void QQuickView_ShowEventDefault(void* ptr, void* ev);
void QQuickView_ShowFullScreen(void* ptr);
void QQuickView_ShowFullScreenDefault(void* ptr);
void QQuickView_ShowMaximized(void* ptr);
@ -629,6 +661,8 @@ void QQuickView_TabletEvent(void* ptr, void* ev);
void QQuickView_TabletEventDefault(void* ptr, void* ev);
void QQuickView_TouchEvent(void* ptr, void* ev);
void QQuickView_TouchEventDefault(void* ptr, void* ev);
void QQuickView_WheelEvent(void* ptr, void* ev);
void QQuickView_WheelEventDefault(void* ptr, void* ev);
void QQuickView_TimerEvent(void* ptr, void* event);
void QQuickView_TimerEventDefault(void* ptr, void* event);
void QQuickView_ChildEvent(void* ptr, void* event);
@ -795,6 +829,10 @@ char QQuickWidget_EventFilter(void* ptr, void* watched, void* event);
char QQuickWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QQuickWidget_MetaObject(void* ptr);
void* QQuickWidget_MetaObjectDefault(void* ptr);
int QQuickWidget_Metric(void* ptr, long long metric);
int QQuickWidget_MetricDefault(void* ptr, long long metric);
void* QQuickWidget_PaintEngine(void* ptr);
void* QQuickWidget_PaintEngineDefault(void* ptr);
void* QQuickWindow_ActiveFocusItem(void* ptr);
void* QQuickWindow_Color(void* ptr);
void* QQuickWindow_ContentItem(void* ptr);

View file

@ -2109,6 +2109,16 @@ char QSqlRelationalDelegate_EventDefault(void* ptr, void* e)
return static_cast<QSqlRelationalDelegate*>(ptr)->QSqlRelationalDelegate::event(static_cast<QEvent*>(e));
}
char QSqlRelationalDelegate_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSqlRelationalDelegate*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
char QSqlRelationalDelegate_EventFilterDefault(void* ptr, void* watched, void* event)
{
return static_cast<QSqlRelationalDelegate*>(ptr)->QSqlRelationalDelegate::eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
}
void* QSqlRelationalDelegate_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QSqlRelationalDelegate*>(ptr)->metaObject());
@ -2147,15 +2157,26 @@ public:
void queryChange() { callbackQSqlRelationalTableModel_QueryChange(this); };
QModelIndex index(int row, int column, const QModelIndex & parent) const { return *static_cast<QModelIndex*>(callbackQSqlRelationalTableModel_Index(const_cast<MyQSqlRelationalTableModel*>(this), row, column, const_cast<QModelIndex*>(&parent))); };
bool dropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) { return callbackQSqlRelationalTableModel_DropMimeData(this, const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
Qt::ItemFlags flags(const QModelIndex & index) const { return static_cast<Qt::ItemFlag>(callbackQSqlRelationalTableModel_Flags(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&index))); };
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQSqlRelationalTableModel_Sibling(const_cast<MyQSqlRelationalTableModel*>(this), row, column, const_cast<QModelIndex*>(&idx))); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQSqlRelationalTableModel_Buddy(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQSqlRelationalTableModel_CanDropMimeData(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQSqlRelationalTableModel_CanFetchMore(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQSqlRelationalTableModel_ColumnCount(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&parent)); };
void fetchMore(const QModelIndex & parent) { callbackQSqlRelationalTableModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
bool hasChildren(const QModelIndex & parent) const { return callbackQSqlRelationalTableModel_HasChildren(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&parent)) != 0; };
QVariant headerData(int section, Qt::Orientation orientation, int role) const { return *static_cast<QVariant*>(callbackQSqlRelationalTableModel_HeaderData(const_cast<MyQSqlRelationalTableModel*>(this), section, orientation, role)); };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQSqlRelationalTableModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
bool insertRows(int row, int count, const QModelIndex & parent) { return callbackQSqlRelationalTableModel_InsertRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
QStringList mimeTypes() const { return QString(callbackQSqlRelationalTableModel_MimeTypes(const_cast<MyQSqlRelationalTableModel*>(this))).split("|", QString::SkipEmptyParts); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQSqlRelationalTableModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQSqlRelationalTableModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQSqlRelationalTableModel_Parent(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&index))); };
bool removeRows(int row, int count, const QModelIndex & parent) { return callbackQSqlRelationalTableModel_RemoveRows(this, row, count, const_cast<QModelIndex*>(&parent)) != 0; };
void resetInternalData() { callbackQSqlRelationalTableModel_ResetInternalData(this); };
int rowCount(const QModelIndex & parent) const { return callbackQSqlRelationalTableModel_RowCount(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&parent)); };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQSqlRelationalTableModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
void sort(int column, Qt::SortOrder order) { callbackQSqlRelationalTableModel_Sort(this, column, order); };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQSqlRelationalTableModel_Span(const_cast<MyQSqlRelationalTableModel*>(this), const_cast<QModelIndex*>(&index))); };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQSqlRelationalTableModel_SupportedDragActions(const_cast<MyQSqlRelationalTableModel*>(this))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQSqlRelationalTableModel_SupportedDropActions(const_cast<MyQSqlRelationalTableModel*>(this))); };
@ -2446,6 +2467,16 @@ char QSqlRelationalTableModel_DropMimeDataDefault(void* ptr, void* data, long lo
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::dropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
long long QSqlRelationalTableModel_Flags(void* ptr, void* index)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->flags(*static_cast<QModelIndex*>(index));
}
long long QSqlRelationalTableModel_FlagsDefault(void* ptr, void* index)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::flags(*static_cast<QModelIndex*>(index));
}
void* QSqlRelationalTableModel_Sibling(void* ptr, int row, int column, void* idx)
{
return new QModelIndex(static_cast<QSqlRelationalTableModel*>(ptr)->sibling(row, column, *static_cast<QModelIndex*>(idx)));
@ -2476,6 +2507,36 @@ char QSqlRelationalTableModel_CanDropMimeDataDefault(void* ptr, void* data, long
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_CanFetchMore(void* ptr, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->canFetchMore(*static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_CanFetchMoreDefault(void* ptr, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::canFetchMore(*static_cast<QModelIndex*>(parent));
}
int QSqlRelationalTableModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QSqlRelationalTableModel_ColumnCountDefault(void* ptr, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::columnCount(*static_cast<QModelIndex*>(parent));
}
void QSqlRelationalTableModel_FetchMore(void* ptr, void* parent)
{
static_cast<QSqlRelationalTableModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
}
void QSqlRelationalTableModel_FetchMoreDefault(void* ptr, void* parent)
{
static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::fetchMore(*static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_HasChildren(void* ptr, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->hasChildren(*static_cast<QModelIndex*>(parent));
@ -2486,6 +2547,36 @@ char QSqlRelationalTableModel_HasChildrenDefault(void* ptr, void* parent)
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::hasChildren(*static_cast<QModelIndex*>(parent));
}
void* QSqlRelationalTableModel_HeaderData(void* ptr, int section, long long orientation, int role)
{
return new QVariant(static_cast<QSqlRelationalTableModel*>(ptr)->headerData(section, static_cast<Qt::Orientation>(orientation), role));
}
void* QSqlRelationalTableModel_HeaderDataDefault(void* ptr, int section, long long orientation, int role)
{
return new QVariant(static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::headerData(section, static_cast<Qt::Orientation>(orientation), role));
}
char QSqlRelationalTableModel_InsertColumns(void* ptr, int column, int count, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_InsertRows(void* ptr, int row, int count, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_InsertRowsDefault(void* ptr, int row, int count, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::insertRows(row, count, *static_cast<QModelIndex*>(parent));
}
struct QtSql_PackedString QSqlRelationalTableModel_MimeTypes(void* ptr)
{
return ({ QByteArray te5a031 = static_cast<QSqlRelationalTableModel*>(ptr)->mimeTypes().join("|").toUtf8(); QtSql_PackedString { const_cast<char*>(te5a031.prepend("WHITESPACE").constData()+10), te5a031.size()-10 }; });
@ -2526,6 +2617,16 @@ void* QSqlRelationalTableModel_ParentDefault(void* ptr, void* index)
return new QModelIndex(static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::parent(*static_cast<QModelIndex*>(index)));
}
char QSqlRelationalTableModel_RemoveRows(void* ptr, int row, int count, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->removeRows(row, count, *static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_RemoveRowsDefault(void* ptr, int row, int count, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::removeRows(row, count, *static_cast<QModelIndex*>(parent));
}
void QSqlRelationalTableModel_ResetInternalData(void* ptr)
{
QMetaObject::invokeMethod(static_cast<QSqlRelationalTableModel*>(ptr), "resetInternalData");
@ -2536,6 +2637,36 @@ void QSqlRelationalTableModel_ResetInternalDataDefault(void* ptr)
static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::resetInternalData();
}
int QSqlRelationalTableModel_RowCount(void* ptr, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->rowCount(*static_cast<QModelIndex*>(parent));
}
int QSqlRelationalTableModel_RowCountDefault(void* ptr, void* parent)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::rowCount(*static_cast<QModelIndex*>(parent));
}
char QSqlRelationalTableModel_SetHeaderData(void* ptr, int section, long long orientation, void* value, int role)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
char QSqlRelationalTableModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role)
{
return static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
void QSqlRelationalTableModel_Sort(void* ptr, int column, long long order)
{
static_cast<QSqlRelationalTableModel*>(ptr)->sort(column, static_cast<Qt::SortOrder>(order));
}
void QSqlRelationalTableModel_SortDefault(void* ptr, int column, long long order)
{
static_cast<QSqlRelationalTableModel*>(ptr)->QSqlRelationalTableModel::sort(column, static_cast<Qt::SortOrder>(order));
}
void* QSqlRelationalTableModel_Span(void* ptr, void* index)
{
return ({ QSize tmpValue = static_cast<QSqlRelationalTableModel*>(ptr)->span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });
@ -3045,12 +3176,17 @@ public:
QModelIndex sibling(int row, int column, const QModelIndex & idx) const { return *static_cast<QModelIndex*>(callbackQSqlTableModel_Sibling(const_cast<MyQSqlTableModel*>(this), row, column, const_cast<QModelIndex*>(&idx))); };
QModelIndex buddy(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQSqlTableModel_Buddy(const_cast<MyQSqlTableModel*>(this), const_cast<QModelIndex*>(&index))); };
bool canDropMimeData(const QMimeData * data, Qt::DropAction action, int row, int column, const QModelIndex & parent) const { return callbackQSqlTableModel_CanDropMimeData(const_cast<MyQSqlTableModel*>(this), const_cast<QMimeData*>(data), action, row, column, const_cast<QModelIndex*>(&parent)) != 0; };
bool canFetchMore(const QModelIndex & parent) const { return callbackQSqlTableModel_CanFetchMore(const_cast<MyQSqlTableModel*>(this), const_cast<QModelIndex*>(&parent)) != 0; };
int columnCount(const QModelIndex & parent) const { return callbackQSqlTableModel_ColumnCount(const_cast<MyQSqlTableModel*>(this), const_cast<QModelIndex*>(&parent)); };
void fetchMore(const QModelIndex & parent) { callbackQSqlTableModel_FetchMore(this, const_cast<QModelIndex*>(&parent)); };
bool hasChildren(const QModelIndex & parent) const { return callbackQSqlTableModel_HasChildren(const_cast<MyQSqlTableModel*>(this), const_cast<QModelIndex*>(&parent)) != 0; };
bool insertColumns(int column, int count, const QModelIndex & parent) { return callbackQSqlTableModel_InsertColumns(this, column, count, const_cast<QModelIndex*>(&parent)) != 0; };
QStringList mimeTypes() const { return QString(callbackQSqlTableModel_MimeTypes(const_cast<MyQSqlTableModel*>(this))).split("|", QString::SkipEmptyParts); };
bool moveColumns(const QModelIndex & sourceParent, int sourceColumn, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQSqlTableModel_MoveColumns(this, const_cast<QModelIndex*>(&sourceParent), sourceColumn, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
bool moveRows(const QModelIndex & sourceParent, int sourceRow, int count, const QModelIndex & destinationParent, int destinationChild) { return callbackQSqlTableModel_MoveRows(this, const_cast<QModelIndex*>(&sourceParent), sourceRow, count, const_cast<QModelIndex*>(&destinationParent), destinationChild) != 0; };
QModelIndex parent(const QModelIndex & index) const { return *static_cast<QModelIndex*>(callbackQSqlTableModel_Parent(const_cast<MyQSqlTableModel*>(this), const_cast<QModelIndex*>(&index))); };
void resetInternalData() { callbackQSqlTableModel_ResetInternalData(this); };
bool setHeaderData(int section, Qt::Orientation orientation, const QVariant & value, int role) { return callbackQSqlTableModel_SetHeaderData(this, section, orientation, const_cast<QVariant*>(&value), role) != 0; };
QSize span(const QModelIndex & index) const { return *static_cast<QSize*>(callbackQSqlTableModel_Span(const_cast<MyQSqlTableModel*>(this), const_cast<QModelIndex*>(&index))); };
Qt::DropActions supportedDragActions() const { return static_cast<Qt::DropAction>(callbackQSqlTableModel_SupportedDragActions(const_cast<MyQSqlTableModel*>(this))); };
Qt::DropActions supportedDropActions() const { return static_cast<Qt::DropAction>(callbackQSqlTableModel_SupportedDropActions(const_cast<MyQSqlTableModel*>(this))); };
@ -3488,6 +3624,36 @@ char QSqlTableModel_CanDropMimeDataDefault(void* ptr, void* data, long long acti
return static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::canDropMimeData(static_cast<QMimeData*>(data), static_cast<Qt::DropAction>(action), row, column, *static_cast<QModelIndex*>(parent));
}
char QSqlTableModel_CanFetchMore(void* ptr, void* parent)
{
return static_cast<QSqlTableModel*>(ptr)->canFetchMore(*static_cast<QModelIndex*>(parent));
}
char QSqlTableModel_CanFetchMoreDefault(void* ptr, void* parent)
{
return static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::canFetchMore(*static_cast<QModelIndex*>(parent));
}
int QSqlTableModel_ColumnCount(void* ptr, void* parent)
{
return static_cast<QSqlTableModel*>(ptr)->columnCount(*static_cast<QModelIndex*>(parent));
}
int QSqlTableModel_ColumnCountDefault(void* ptr, void* parent)
{
return static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::columnCount(*static_cast<QModelIndex*>(parent));
}
void QSqlTableModel_FetchMore(void* ptr, void* parent)
{
static_cast<QSqlTableModel*>(ptr)->fetchMore(*static_cast<QModelIndex*>(parent));
}
void QSqlTableModel_FetchMoreDefault(void* ptr, void* parent)
{
static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::fetchMore(*static_cast<QModelIndex*>(parent));
}
char QSqlTableModel_HasChildren(void* ptr, void* parent)
{
return static_cast<QSqlTableModel*>(ptr)->hasChildren(*static_cast<QModelIndex*>(parent));
@ -3498,6 +3664,16 @@ char QSqlTableModel_HasChildrenDefault(void* ptr, void* parent)
return static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::hasChildren(*static_cast<QModelIndex*>(parent));
}
char QSqlTableModel_InsertColumns(void* ptr, int column, int count, void* parent)
{
return static_cast<QSqlTableModel*>(ptr)->insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
char QSqlTableModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent)
{
return static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::insertColumns(column, count, *static_cast<QModelIndex*>(parent));
}
struct QtSql_PackedString QSqlTableModel_MimeTypes(void* ptr)
{
return ({ QByteArray tabeef0 = static_cast<QSqlTableModel*>(ptr)->mimeTypes().join("|").toUtf8(); QtSql_PackedString { const_cast<char*>(tabeef0.prepend("WHITESPACE").constData()+10), tabeef0.size()-10 }; });
@ -3548,6 +3724,16 @@ void QSqlTableModel_ResetInternalDataDefault(void* ptr)
static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::resetInternalData();
}
char QSqlTableModel_SetHeaderData(void* ptr, int section, long long orientation, void* value, int role)
{
return static_cast<QSqlTableModel*>(ptr)->setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
char QSqlTableModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role)
{
return static_cast<QSqlTableModel*>(ptr)->QSqlTableModel::setHeaderData(section, static_cast<Qt::Orientation>(orientation), *static_cast<QVariant*>(value), role);
}
void* QSqlTableModel_Span(void* ptr, void* index)
{
return ({ QSize tmpValue = static_cast<QSqlTableModel*>(ptr)->span(*static_cast<QModelIndex*>(index)); new QSize(tmpValue.width(), tmpValue.height()); });

View file

@ -5930,6 +5930,44 @@ func (ptr *QSqlRelationalDelegate) EventDefault(e core.QEvent_ITF) bool {
return false
}
//export callbackQSqlRelationalDelegate_EventFilter
func callbackQSqlRelationalDelegate_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalDelegate::eventFilter"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlRelationalDelegateFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
}
func (ptr *QSqlRelationalDelegate) ConnectEventFilter(f func(watched *core.QObject, event *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalDelegate::eventFilter", f)
}
}
func (ptr *QSqlRelationalDelegate) DisconnectEventFilter() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalDelegate::eventFilter")
}
}
func (ptr *QSqlRelationalDelegate) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalDelegate_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
func (ptr *QSqlRelationalDelegate) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalDelegate_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
}
return false
}
//export callbackQSqlRelationalDelegate_MetaObject
func callbackQSqlRelationalDelegate_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
@ -6972,6 +7010,44 @@ func (ptr *QSqlRelationalTableModel) DropMimeDataDefault(data core.QMimeData_ITF
return false
}
//export callbackQSqlRelationalTableModel_Flags
func callbackQSqlRelationalTableModel_Flags(ptr unsafe.Pointer, index unsafe.Pointer) C.longlong {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::flags"); signal != nil {
return C.longlong(signal.(func(*core.QModelIndex) core.Qt__ItemFlag)(core.NewQModelIndexFromPointer(index)))
}
return C.longlong(NewQSqlRelationalTableModelFromPointer(ptr).FlagsDefault(core.NewQModelIndexFromPointer(index)))
}
func (ptr *QSqlRelationalTableModel) ConnectFlags(f func(index *core.QModelIndex) core.Qt__ItemFlag) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::flags", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectFlags() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::flags")
}
}
func (ptr *QSqlRelationalTableModel) Flags(index core.QModelIndex_ITF) core.Qt__ItemFlag {
if ptr.Pointer() != nil {
return core.Qt__ItemFlag(C.QSqlRelationalTableModel_Flags(ptr.Pointer(), core.PointerFromQModelIndex(index)))
}
return 0
}
func (ptr *QSqlRelationalTableModel) FlagsDefault(index core.QModelIndex_ITF) core.Qt__ItemFlag {
if ptr.Pointer() != nil {
return core.Qt__ItemFlag(C.QSqlRelationalTableModel_FlagsDefault(ptr.Pointer(), core.PointerFromQModelIndex(index)))
}
return 0
}
//export callbackQSqlRelationalTableModel_Sibling
func callbackQSqlRelationalTableModel_Sibling(ptr unsafe.Pointer, row C.int, column C.int, idx unsafe.Pointer) unsafe.Pointer {
@ -7094,6 +7170,118 @@ func (ptr *QSqlRelationalTableModel) CanDropMimeDataDefault(data core.QMimeData_
return false
}
//export callbackQSqlRelationalTableModel_CanFetchMore
func callbackQSqlRelationalTableModel_CanFetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::canFetchMore"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QModelIndex) bool)(core.NewQModelIndexFromPointer(parent)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlRelationalTableModelFromPointer(ptr).CanFetchMoreDefault(core.NewQModelIndexFromPointer(parent)))))
}
func (ptr *QSqlRelationalTableModel) ConnectCanFetchMore(f func(parent *core.QModelIndex) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::canFetchMore", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectCanFetchMore() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::canFetchMore")
}
}
func (ptr *QSqlRelationalTableModel) CanFetchMore(parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_CanFetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
func (ptr *QSqlRelationalTableModel) CanFetchMoreDefault(parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_CanFetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
//export callbackQSqlRelationalTableModel_ColumnCount
func callbackQSqlRelationalTableModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::columnCount"); signal != nil {
return C.int(int32(signal.(func(*core.QModelIndex) int)(core.NewQModelIndexFromPointer(parent))))
}
return C.int(int32(NewQSqlRelationalTableModelFromPointer(ptr).ColumnCountDefault(core.NewQModelIndexFromPointer(parent))))
}
func (ptr *QSqlRelationalTableModel) ConnectColumnCount(f func(parent *core.QModelIndex) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::columnCount", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectColumnCount() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::columnCount")
}
}
func (ptr *QSqlRelationalTableModel) ColumnCount(parent core.QModelIndex_ITF) int {
if ptr.Pointer() != nil {
return int(int32(C.QSqlRelationalTableModel_ColumnCount(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
}
return 0
}
func (ptr *QSqlRelationalTableModel) ColumnCountDefault(parent core.QModelIndex_ITF) int {
if ptr.Pointer() != nil {
return int(int32(C.QSqlRelationalTableModel_ColumnCountDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
}
return 0
}
//export callbackQSqlRelationalTableModel_FetchMore
func callbackQSqlRelationalTableModel_FetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::fetchMore"); signal != nil {
signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
} else {
NewQSqlRelationalTableModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
}
}
func (ptr *QSqlRelationalTableModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::fetchMore", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectFetchMore() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::fetchMore")
}
}
func (ptr *QSqlRelationalTableModel) FetchMore(parent core.QModelIndex_ITF) {
if ptr.Pointer() != nil {
C.QSqlRelationalTableModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
}
}
func (ptr *QSqlRelationalTableModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
if ptr.Pointer() != nil {
C.QSqlRelationalTableModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
}
}
//export callbackQSqlRelationalTableModel_HasChildren
func callbackQSqlRelationalTableModel_HasChildren(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
@ -7132,6 +7320,124 @@ func (ptr *QSqlRelationalTableModel) HasChildrenDefault(parent core.QModelIndex_
return false
}
//export callbackQSqlRelationalTableModel_HeaderData
func callbackQSqlRelationalTableModel_HeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, role C.int) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::headerData"); signal != nil {
return core.PointerFromQVariant(signal.(func(int, core.Qt__Orientation, int) *core.QVariant)(int(int32(section)), core.Qt__Orientation(orientation), int(int32(role))))
}
return core.PointerFromQVariant(NewQSqlRelationalTableModelFromPointer(ptr).HeaderDataDefault(int(int32(section)), core.Qt__Orientation(orientation), int(int32(role))))
}
func (ptr *QSqlRelationalTableModel) ConnectHeaderData(f func(section int, orientation core.Qt__Orientation, role int) *core.QVariant) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::headerData", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectHeaderData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::headerData")
}
}
func (ptr *QSqlRelationalTableModel) HeaderData(section int, orientation core.Qt__Orientation, role int) *core.QVariant {
if ptr.Pointer() != nil {
var tmpValue = core.NewQVariantFromPointer(C.QSqlRelationalTableModel_HeaderData(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), C.int(int32(role))))
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
return tmpValue
}
return nil
}
func (ptr *QSqlRelationalTableModel) HeaderDataDefault(section int, orientation core.Qt__Orientation, role int) *core.QVariant {
if ptr.Pointer() != nil {
var tmpValue = core.NewQVariantFromPointer(C.QSqlRelationalTableModel_HeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), C.int(int32(role))))
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
return tmpValue
}
return nil
}
//export callbackQSqlRelationalTableModel_InsertColumns
func callbackQSqlRelationalTableModel_InsertColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::insertColumns"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int, int, *core.QModelIndex) bool)(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlRelationalTableModelFromPointer(ptr).InsertColumnsDefault(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
func (ptr *QSqlRelationalTableModel) ConnectInsertColumns(f func(column int, count int, parent *core.QModelIndex) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::insertColumns", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectInsertColumns() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::insertColumns")
}
}
func (ptr *QSqlRelationalTableModel) InsertColumns(column int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_InsertColumns(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
func (ptr *QSqlRelationalTableModel) InsertColumnsDefault(column int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_InsertColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
//export callbackQSqlRelationalTableModel_InsertRows
func callbackQSqlRelationalTableModel_InsertRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::insertRows"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int, int, *core.QModelIndex) bool)(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlRelationalTableModelFromPointer(ptr).InsertRowsDefault(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
func (ptr *QSqlRelationalTableModel) ConnectInsertRows(f func(row int, count int, parent *core.QModelIndex) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::insertRows", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectInsertRows() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::insertRows")
}
}
func (ptr *QSqlRelationalTableModel) InsertRows(row int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_InsertRows(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
func (ptr *QSqlRelationalTableModel) InsertRowsDefault(row int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_InsertRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
//export callbackQSqlRelationalTableModel_MimeTypes
func callbackQSqlRelationalTableModel_MimeTypes(ptr unsafe.Pointer) *C.char {
@ -7288,6 +7594,44 @@ func (ptr *QSqlRelationalTableModel) ParentDefault(index core.QModelIndex_ITF) *
return nil
}
//export callbackQSqlRelationalTableModel_RemoveRows
func callbackQSqlRelationalTableModel_RemoveRows(ptr unsafe.Pointer, row C.int, count C.int, parent unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::removeRows"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int, int, *core.QModelIndex) bool)(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlRelationalTableModelFromPointer(ptr).RemoveRowsDefault(int(int32(row)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
func (ptr *QSqlRelationalTableModel) ConnectRemoveRows(f func(row int, count int, parent *core.QModelIndex) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::removeRows", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectRemoveRows() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::removeRows")
}
}
func (ptr *QSqlRelationalTableModel) RemoveRows(row int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_RemoveRows(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
func (ptr *QSqlRelationalTableModel) RemoveRowsDefault(row int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_RemoveRowsDefault(ptr.Pointer(), C.int(int32(row)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
//export callbackQSqlRelationalTableModel_ResetInternalData
func callbackQSqlRelationalTableModel_ResetInternalData(ptr unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::resetInternalData"); signal != nil {
@ -7323,6 +7667,118 @@ func (ptr *QSqlRelationalTableModel) ResetInternalDataDefault() {
}
}
//export callbackQSqlRelationalTableModel_RowCount
func callbackQSqlRelationalTableModel_RowCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::rowCount"); signal != nil {
return C.int(int32(signal.(func(*core.QModelIndex) int)(core.NewQModelIndexFromPointer(parent))))
}
return C.int(int32(NewQSqlRelationalTableModelFromPointer(ptr).RowCountDefault(core.NewQModelIndexFromPointer(parent))))
}
func (ptr *QSqlRelationalTableModel) ConnectRowCount(f func(parent *core.QModelIndex) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::rowCount", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectRowCount() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::rowCount")
}
}
func (ptr *QSqlRelationalTableModel) RowCount(parent core.QModelIndex_ITF) int {
if ptr.Pointer() != nil {
return int(int32(C.QSqlRelationalTableModel_RowCount(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
}
return 0
}
func (ptr *QSqlRelationalTableModel) RowCountDefault(parent core.QModelIndex_ITF) int {
if ptr.Pointer() != nil {
return int(int32(C.QSqlRelationalTableModel_RowCountDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
}
return 0
}
//export callbackQSqlRelationalTableModel_SetHeaderData
func callbackQSqlRelationalTableModel_SetHeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, value unsafe.Pointer, role C.int) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::setHeaderData"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int, core.Qt__Orientation, *core.QVariant, int) bool)(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlRelationalTableModelFromPointer(ptr).SetHeaderDataDefault(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
}
func (ptr *QSqlRelationalTableModel) ConnectSetHeaderData(f func(section int, orientation core.Qt__Orientation, value *core.QVariant, role int) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::setHeaderData", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectSetHeaderData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::setHeaderData")
}
}
func (ptr *QSqlRelationalTableModel) SetHeaderData(section int, orientation core.Qt__Orientation, value core.QVariant_ITF, role int) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_SetHeaderData(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), core.PointerFromQVariant(value), C.int(int32(role))) != 0
}
return false
}
func (ptr *QSqlRelationalTableModel) SetHeaderDataDefault(section int, orientation core.Qt__Orientation, value core.QVariant_ITF, role int) bool {
if ptr.Pointer() != nil {
return C.QSqlRelationalTableModel_SetHeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), core.PointerFromQVariant(value), C.int(int32(role))) != 0
}
return false
}
//export callbackQSqlRelationalTableModel_Sort
func callbackQSqlRelationalTableModel_Sort(ptr unsafe.Pointer, column C.int, order C.longlong) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlRelationalTableModel::sort"); signal != nil {
signal.(func(int, core.Qt__SortOrder))(int(int32(column)), core.Qt__SortOrder(order))
} else {
NewQSqlRelationalTableModelFromPointer(ptr).SortDefault(int(int32(column)), core.Qt__SortOrder(order))
}
}
func (ptr *QSqlRelationalTableModel) ConnectSort(f func(column int, order core.Qt__SortOrder)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::sort", f)
}
}
func (ptr *QSqlRelationalTableModel) DisconnectSort() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlRelationalTableModel::sort")
}
}
func (ptr *QSqlRelationalTableModel) Sort(column int, order core.Qt__SortOrder) {
if ptr.Pointer() != nil {
C.QSqlRelationalTableModel_Sort(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
}
}
func (ptr *QSqlRelationalTableModel) SortDefault(column int, order core.Qt__SortOrder) {
if ptr.Pointer() != nil {
C.QSqlRelationalTableModel_SortDefault(ptr.Pointer(), C.int(int32(column)), C.longlong(order))
}
}
//export callbackQSqlRelationalTableModel_Span
func callbackQSqlRelationalTableModel_Span(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {
@ -10184,6 +10640,118 @@ func (ptr *QSqlTableModel) CanDropMimeDataDefault(data core.QMimeData_ITF, actio
return false
}
//export callbackQSqlTableModel_CanFetchMore
func callbackQSqlTableModel_CanFetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlTableModel::canFetchMore"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QModelIndex) bool)(core.NewQModelIndexFromPointer(parent)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlTableModelFromPointer(ptr).CanFetchMoreDefault(core.NewQModelIndexFromPointer(parent)))))
}
func (ptr *QSqlTableModel) ConnectCanFetchMore(f func(parent *core.QModelIndex) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::canFetchMore", f)
}
}
func (ptr *QSqlTableModel) DisconnectCanFetchMore() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::canFetchMore")
}
}
func (ptr *QSqlTableModel) CanFetchMore(parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlTableModel_CanFetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
func (ptr *QSqlTableModel) CanFetchMoreDefault(parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlTableModel_CanFetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
//export callbackQSqlTableModel_ColumnCount
func callbackQSqlTableModel_ColumnCount(ptr unsafe.Pointer, parent unsafe.Pointer) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlTableModel::columnCount"); signal != nil {
return C.int(int32(signal.(func(*core.QModelIndex) int)(core.NewQModelIndexFromPointer(parent))))
}
return C.int(int32(NewQSqlTableModelFromPointer(ptr).ColumnCountDefault(core.NewQModelIndexFromPointer(parent))))
}
func (ptr *QSqlTableModel) ConnectColumnCount(f func(parent *core.QModelIndex) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::columnCount", f)
}
}
func (ptr *QSqlTableModel) DisconnectColumnCount() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::columnCount")
}
}
func (ptr *QSqlTableModel) ColumnCount(parent core.QModelIndex_ITF) int {
if ptr.Pointer() != nil {
return int(int32(C.QSqlTableModel_ColumnCount(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
}
return 0
}
func (ptr *QSqlTableModel) ColumnCountDefault(parent core.QModelIndex_ITF) int {
if ptr.Pointer() != nil {
return int(int32(C.QSqlTableModel_ColumnCountDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))))
}
return 0
}
//export callbackQSqlTableModel_FetchMore
func callbackQSqlTableModel_FetchMore(ptr unsafe.Pointer, parent unsafe.Pointer) {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlTableModel::fetchMore"); signal != nil {
signal.(func(*core.QModelIndex))(core.NewQModelIndexFromPointer(parent))
} else {
NewQSqlTableModelFromPointer(ptr).FetchMoreDefault(core.NewQModelIndexFromPointer(parent))
}
}
func (ptr *QSqlTableModel) ConnectFetchMore(f func(parent *core.QModelIndex)) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::fetchMore", f)
}
}
func (ptr *QSqlTableModel) DisconnectFetchMore() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::fetchMore")
}
}
func (ptr *QSqlTableModel) FetchMore(parent core.QModelIndex_ITF) {
if ptr.Pointer() != nil {
C.QSqlTableModel_FetchMore(ptr.Pointer(), core.PointerFromQModelIndex(parent))
}
}
func (ptr *QSqlTableModel) FetchMoreDefault(parent core.QModelIndex_ITF) {
if ptr.Pointer() != nil {
C.QSqlTableModel_FetchMoreDefault(ptr.Pointer(), core.PointerFromQModelIndex(parent))
}
}
//export callbackQSqlTableModel_HasChildren
func callbackQSqlTableModel_HasChildren(ptr unsafe.Pointer, parent unsafe.Pointer) C.char {
@ -10222,6 +10790,44 @@ func (ptr *QSqlTableModel) HasChildrenDefault(parent core.QModelIndex_ITF) bool
return false
}
//export callbackQSqlTableModel_InsertColumns
func callbackQSqlTableModel_InsertColumns(ptr unsafe.Pointer, column C.int, count C.int, parent unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlTableModel::insertColumns"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int, int, *core.QModelIndex) bool)(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlTableModelFromPointer(ptr).InsertColumnsDefault(int(int32(column)), int(int32(count)), core.NewQModelIndexFromPointer(parent)))))
}
func (ptr *QSqlTableModel) ConnectInsertColumns(f func(column int, count int, parent *core.QModelIndex) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::insertColumns", f)
}
}
func (ptr *QSqlTableModel) DisconnectInsertColumns() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::insertColumns")
}
}
func (ptr *QSqlTableModel) InsertColumns(column int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlTableModel_InsertColumns(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
func (ptr *QSqlTableModel) InsertColumnsDefault(column int, count int, parent core.QModelIndex_ITF) bool {
if ptr.Pointer() != nil {
return C.QSqlTableModel_InsertColumnsDefault(ptr.Pointer(), C.int(int32(column)), C.int(int32(count)), core.PointerFromQModelIndex(parent)) != 0
}
return false
}
//export callbackQSqlTableModel_MimeTypes
func callbackQSqlTableModel_MimeTypes(ptr unsafe.Pointer) *C.char {
@ -10413,6 +11019,44 @@ func (ptr *QSqlTableModel) ResetInternalDataDefault() {
}
}
//export callbackQSqlTableModel_SetHeaderData
func callbackQSqlTableModel_SetHeaderData(ptr unsafe.Pointer, section C.int, orientation C.longlong, value unsafe.Pointer, role C.int) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSqlTableModel::setHeaderData"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(int, core.Qt__Orientation, *core.QVariant, int) bool)(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
}
return C.char(int8(qt.GoBoolToInt(NewQSqlTableModelFromPointer(ptr).SetHeaderDataDefault(int(int32(section)), core.Qt__Orientation(orientation), core.NewQVariantFromPointer(value), int(int32(role))))))
}
func (ptr *QSqlTableModel) ConnectSetHeaderData(f func(section int, orientation core.Qt__Orientation, value *core.QVariant, role int) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::setHeaderData", f)
}
}
func (ptr *QSqlTableModel) DisconnectSetHeaderData() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSqlTableModel::setHeaderData")
}
}
func (ptr *QSqlTableModel) SetHeaderData(section int, orientation core.Qt__Orientation, value core.QVariant_ITF, role int) bool {
if ptr.Pointer() != nil {
return C.QSqlTableModel_SetHeaderData(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), core.PointerFromQVariant(value), C.int(int32(role))) != 0
}
return false
}
func (ptr *QSqlTableModel) SetHeaderDataDefault(section int, orientation core.Qt__Orientation, value core.QVariant_ITF, role int) bool {
if ptr.Pointer() != nil {
return C.QSqlTableModel_SetHeaderDataDefault(ptr.Pointer(), C.int(int32(section)), C.longlong(orientation), core.PointerFromQVariant(value), C.int(int32(role))) != 0
}
return false
}
//export callbackQSqlTableModel_Span
func callbackQSqlTableModel_Span(ptr unsafe.Pointer, index unsafe.Pointer) unsafe.Pointer {

View file

@ -404,6 +404,8 @@ void QSqlRelationalDelegate_DisconnectNotify(void* ptr, void* sign);
void QSqlRelationalDelegate_DisconnectNotifyDefault(void* ptr, void* sign);
char QSqlRelationalDelegate_Event(void* ptr, void* e);
char QSqlRelationalDelegate_EventDefault(void* ptr, void* e);
char QSqlRelationalDelegate_EventFilter(void* ptr, void* watched, void* event);
char QSqlRelationalDelegate_EventFilterDefault(void* ptr, void* watched, void* event);
void* QSqlRelationalDelegate_MetaObject(void* ptr);
void* QSqlRelationalDelegate_MetaObjectDefault(void* ptr);
void* QSqlRelationalTableModel_NewQSqlRelationalTableModel(void* parent, void* db);
@ -460,14 +462,28 @@ void* QSqlRelationalTableModel_Index(void* ptr, int row, int column, void* paren
void* QSqlRelationalTableModel_IndexDefault(void* ptr, int row, int column, void* parent);
char QSqlRelationalTableModel_DropMimeData(void* ptr, void* data, long long action, int row, int column, void* parent);
char QSqlRelationalTableModel_DropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent);
long long QSqlRelationalTableModel_Flags(void* ptr, void* index);
long long QSqlRelationalTableModel_FlagsDefault(void* ptr, void* index);
void* QSqlRelationalTableModel_Sibling(void* ptr, int row, int column, void* idx);
void* QSqlRelationalTableModel_SiblingDefault(void* ptr, int row, int column, void* idx);
void* QSqlRelationalTableModel_Buddy(void* ptr, void* index);
void* QSqlRelationalTableModel_BuddyDefault(void* ptr, void* index);
char QSqlRelationalTableModel_CanDropMimeData(void* ptr, void* data, long long action, int row, int column, void* parent);
char QSqlRelationalTableModel_CanDropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent);
char QSqlRelationalTableModel_CanFetchMore(void* ptr, void* parent);
char QSqlRelationalTableModel_CanFetchMoreDefault(void* ptr, void* parent);
int QSqlRelationalTableModel_ColumnCount(void* ptr, void* parent);
int QSqlRelationalTableModel_ColumnCountDefault(void* ptr, void* parent);
void QSqlRelationalTableModel_FetchMore(void* ptr, void* parent);
void QSqlRelationalTableModel_FetchMoreDefault(void* ptr, void* parent);
char QSqlRelationalTableModel_HasChildren(void* ptr, void* parent);
char QSqlRelationalTableModel_HasChildrenDefault(void* ptr, void* parent);
void* QSqlRelationalTableModel_HeaderData(void* ptr, int section, long long orientation, int role);
void* QSqlRelationalTableModel_HeaderDataDefault(void* ptr, int section, long long orientation, int role);
char QSqlRelationalTableModel_InsertColumns(void* ptr, int column, int count, void* parent);
char QSqlRelationalTableModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent);
char QSqlRelationalTableModel_InsertRows(void* ptr, int row, int count, void* parent);
char QSqlRelationalTableModel_InsertRowsDefault(void* ptr, int row, int count, void* parent);
struct QtSql_PackedString QSqlRelationalTableModel_MimeTypes(void* ptr);
struct QtSql_PackedString QSqlRelationalTableModel_MimeTypesDefault(void* ptr);
char QSqlRelationalTableModel_MoveColumns(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild);
@ -476,8 +492,16 @@ char QSqlRelationalTableModel_MoveRows(void* ptr, void* sourceParent, int source
char QSqlRelationalTableModel_MoveRowsDefault(void* ptr, void* sourceParent, int sourceRow, int count, void* destinationParent, int destinationChild);
void* QSqlRelationalTableModel_Parent(void* ptr, void* index);
void* QSqlRelationalTableModel_ParentDefault(void* ptr, void* index);
char QSqlRelationalTableModel_RemoveRows(void* ptr, int row, int count, void* parent);
char QSqlRelationalTableModel_RemoveRowsDefault(void* ptr, int row, int count, void* parent);
void QSqlRelationalTableModel_ResetInternalData(void* ptr);
void QSqlRelationalTableModel_ResetInternalDataDefault(void* ptr);
int QSqlRelationalTableModel_RowCount(void* ptr, void* parent);
int QSqlRelationalTableModel_RowCountDefault(void* ptr, void* parent);
char QSqlRelationalTableModel_SetHeaderData(void* ptr, int section, long long orientation, void* value, int role);
char QSqlRelationalTableModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role);
void QSqlRelationalTableModel_Sort(void* ptr, int column, long long order);
void QSqlRelationalTableModel_SortDefault(void* ptr, int column, long long order);
void* QSqlRelationalTableModel_Span(void* ptr, void* index);
void* QSqlRelationalTableModel_SpanDefault(void* ptr, void* index);
long long QSqlRelationalTableModel_SupportedDragActions(void* ptr);
@ -650,8 +674,16 @@ void* QSqlTableModel_Buddy(void* ptr, void* index);
void* QSqlTableModel_BuddyDefault(void* ptr, void* index);
char QSqlTableModel_CanDropMimeData(void* ptr, void* data, long long action, int row, int column, void* parent);
char QSqlTableModel_CanDropMimeDataDefault(void* ptr, void* data, long long action, int row, int column, void* parent);
char QSqlTableModel_CanFetchMore(void* ptr, void* parent);
char QSqlTableModel_CanFetchMoreDefault(void* ptr, void* parent);
int QSqlTableModel_ColumnCount(void* ptr, void* parent);
int QSqlTableModel_ColumnCountDefault(void* ptr, void* parent);
void QSqlTableModel_FetchMore(void* ptr, void* parent);
void QSqlTableModel_FetchMoreDefault(void* ptr, void* parent);
char QSqlTableModel_HasChildren(void* ptr, void* parent);
char QSqlTableModel_HasChildrenDefault(void* ptr, void* parent);
char QSqlTableModel_InsertColumns(void* ptr, int column, int count, void* parent);
char QSqlTableModel_InsertColumnsDefault(void* ptr, int column, int count, void* parent);
struct QtSql_PackedString QSqlTableModel_MimeTypes(void* ptr);
struct QtSql_PackedString QSqlTableModel_MimeTypesDefault(void* ptr);
char QSqlTableModel_MoveColumns(void* ptr, void* sourceParent, int sourceColumn, int count, void* destinationParent, int destinationChild);
@ -662,6 +694,8 @@ void* QSqlTableModel_Parent(void* ptr, void* index);
void* QSqlTableModel_ParentDefault(void* ptr, void* index);
void QSqlTableModel_ResetInternalData(void* ptr);
void QSqlTableModel_ResetInternalDataDefault(void* ptr);
char QSqlTableModel_SetHeaderData(void* ptr, int section, long long orientation, void* value, int role);
char QSqlTableModel_SetHeaderDataDefault(void* ptr, int section, long long orientation, void* value, int role);
void* QSqlTableModel_Span(void* ptr, void* index);
void* QSqlTableModel_SpanDefault(void* ptr, void* index);
long long QSqlTableModel_SupportedDragActions(void* ptr);

View file

@ -38,6 +38,7 @@
#include <QMoveEvent>
#include <QObject>
#include <QPaintDevice>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPainter>
#include <QPainterPath>
@ -79,6 +80,7 @@ public:
void customEvent(QEvent * event) { callbackQGraphicsSvgItem_CustomEvent(this, event); };
void deleteLater() { callbackQGraphicsSvgItem_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQGraphicsSvgItem_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQGraphicsSvgItem_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQGraphicsSvgItem_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQGraphicsSvgItem_MetaObject(const_cast<MyQGraphicsSvgItem*>(this))); };
void advance(int phase) { callbackQGraphicsSvgItem_Advance(this, phase); };
@ -252,6 +254,16 @@ void QGraphicsSvgItem_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QGraphicsSvgItem*>(ptr)->QGraphicsSvgItem::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QGraphicsSvgItem_Event(void* ptr, void* e)
{
return static_cast<QGraphicsSvgItem*>(ptr)->event(static_cast<QEvent*>(e));
}
char QGraphicsSvgItem_EventDefault(void* ptr, void* e)
{
return static_cast<QGraphicsSvgItem*>(ptr)->QGraphicsSvgItem::event(static_cast<QEvent*>(e));
}
char QGraphicsSvgItem_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QGraphicsSvgItem*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -972,8 +984,11 @@ public:
void customEvent(QEvent * event) { callbackQSvgWidget_CustomEvent(this, event); };
void deleteLater() { callbackQSvgWidget_DeleteLater(this); };
void disconnectNotify(const QMetaMethod & sign) { callbackQSvgWidget_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool event(QEvent * e) { return callbackQSvgWidget_Event(this, e) != 0; };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQSvgWidget_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQSvgWidget_MetaObject(const_cast<MyQSvgWidget*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQSvgWidget_Metric(const_cast<MyQSvgWidget*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQSvgWidget_PaintEngine(const_cast<MyQSvgWidget*>(this))); };
};
void* QSvgWidget_NewQSvgWidget(void* parent)
@ -1588,6 +1603,16 @@ void QSvgWidget_DisconnectNotifyDefault(void* ptr, void* sign)
static_cast<QSvgWidget*>(ptr)->QSvgWidget::disconnectNotify(*static_cast<QMetaMethod*>(sign));
}
char QSvgWidget_Event(void* ptr, void* e)
{
return static_cast<QSvgWidget*>(ptr)->event(static_cast<QEvent*>(e));
}
char QSvgWidget_EventDefault(void* ptr, void* e)
{
return static_cast<QSvgWidget*>(ptr)->QSvgWidget::event(static_cast<QEvent*>(e));
}
char QSvgWidget_EventFilter(void* ptr, void* watched, void* event)
{
return static_cast<QSvgWidget*>(ptr)->eventFilter(static_cast<QObject*>(watched), static_cast<QEvent*>(event));
@ -1608,3 +1633,23 @@ void* QSvgWidget_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QSvgWidget*>(ptr)->QSvgWidget::metaObject());
}
int QSvgWidget_Metric(void* ptr, long long metric)
{
return static_cast<QSvgWidget*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QSvgWidget_MetricDefault(void* ptr, long long metric)
{
return static_cast<QSvgWidget*>(ptr)->QSvgWidget::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QSvgWidget_PaintEngine(void* ptr)
{
return static_cast<QSvgWidget*>(ptr)->paintEngine();
}
void* QSvgWidget_PaintEngineDefault(void* ptr)
{
return static_cast<QSvgWidget*>(ptr)->QSvgWidget::paintEngine();
}

View file

@ -503,6 +503,44 @@ func (ptr *QGraphicsSvgItem) DisconnectNotifyDefault(sign core.QMetaMethod_ITF)
}
}
//export callbackQGraphicsSvgItem_Event
func callbackQGraphicsSvgItem_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QGraphicsSvgItem::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQGraphicsSvgItemFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QGraphicsSvgItem) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QGraphicsSvgItem::event", f)
}
}
func (ptr *QGraphicsSvgItem) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QGraphicsSvgItem::event")
}
}
func (ptr *QGraphicsSvgItem) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QGraphicsSvgItem_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QGraphicsSvgItem) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QGraphicsSvgItem_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQGraphicsSvgItem_EventFilter
func callbackQGraphicsSvgItem_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -4763,6 +4801,44 @@ func (ptr *QSvgWidget) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
}
}
//export callbackQSvgWidget_Event
func callbackQSvgWidget_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSvgWidget::event"); signal != nil {
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
}
return C.char(int8(qt.GoBoolToInt(NewQSvgWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
}
func (ptr *QSvgWidget) ConnectEvent(f func(e *core.QEvent) bool) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSvgWidget::event", f)
}
}
func (ptr *QSvgWidget) DisconnectEvent() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSvgWidget::event")
}
}
func (ptr *QSvgWidget) Event(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QSvgWidget_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
func (ptr *QSvgWidget) EventDefault(e core.QEvent_ITF) bool {
if ptr.Pointer() != nil {
return C.QSvgWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
}
return false
}
//export callbackQSvgWidget_EventFilter
func callbackQSvgWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
@ -4838,3 +4914,79 @@ func (ptr *QSvgWidget) MetaObjectDefault() *core.QMetaObject {
}
return nil
}
//export callbackQSvgWidget_Metric
func callbackQSvgWidget_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSvgWidget::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQSvgWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QSvgWidget) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSvgWidget::metric", f)
}
}
func (ptr *QSvgWidget) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSvgWidget::metric")
}
}
func (ptr *QSvgWidget) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QSvgWidget_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QSvgWidget) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QSvgWidget_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQSvgWidget_PaintEngine
func callbackQSvgWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QSvgWidget::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQSvgWidgetFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QSvgWidget) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QSvgWidget::paintEngine", f)
}
}
func (ptr *QSvgWidget) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QSvgWidget::paintEngine")
}
}
func (ptr *QSvgWidget) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QSvgWidget_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QSvgWidget) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QSvgWidget_PaintEngineDefault(ptr.Pointer()))
}
return nil
}

View file

@ -41,6 +41,8 @@ void QGraphicsSvgItem_DeleteLater(void* ptr);
void QGraphicsSvgItem_DeleteLaterDefault(void* ptr);
void QGraphicsSvgItem_DisconnectNotify(void* ptr, void* sign);
void QGraphicsSvgItem_DisconnectNotifyDefault(void* ptr, void* sign);
char QGraphicsSvgItem_Event(void* ptr, void* e);
char QGraphicsSvgItem_EventDefault(void* ptr, void* e);
char QGraphicsSvgItem_EventFilter(void* ptr, void* watched, void* event);
char QGraphicsSvgItem_EventFilterDefault(void* ptr, void* watched, void* event);
void* QGraphicsSvgItem_MetaObject(void* ptr);
@ -288,10 +290,16 @@ void QSvgWidget_DeleteLater(void* ptr);
void QSvgWidget_DeleteLaterDefault(void* ptr);
void QSvgWidget_DisconnectNotify(void* ptr, void* sign);
void QSvgWidget_DisconnectNotifyDefault(void* ptr, void* sign);
char QSvgWidget_Event(void* ptr, void* e);
char QSvgWidget_EventDefault(void* ptr, void* e);
char QSvgWidget_EventFilter(void* ptr, void* watched, void* event);
char QSvgWidget_EventFilterDefault(void* ptr, void* watched, void* event);
void* QSvgWidget_MetaObject(void* ptr);
void* QSvgWidget_MetaObjectDefault(void* ptr);
int QSvgWidget_Metric(void* ptr, long long metric);
int QSvgWidget_MetricDefault(void* ptr, long long metric);
void* QSvgWidget_PaintEngine(void* ptr);
void* QSvgWidget_PaintEngineDefault(void* ptr);
#ifdef __cplusplus
}

View file

@ -37,6 +37,8 @@
#include <QNetworkCookie>
#include <QObject>
#include <QPageLayout>
#include <QPaintDevice>
#include <QPaintEngine>
#include <QPaintEvent>
#include <QPoint>
#include <QPointF>
@ -2744,6 +2746,8 @@ public:
void disconnectNotify(const QMetaMethod & sign) { callbackQWebEngineView_DisconnectNotify(this, const_cast<QMetaMethod*>(&sign)); };
bool eventFilter(QObject * watched, QEvent * event) { return callbackQWebEngineView_EventFilter(this, watched, event) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQWebEngineView_MetaObject(const_cast<MyQWebEngineView*>(this))); };
int metric(QPaintDevice::PaintDeviceMetric metric) const { return callbackQWebEngineView_Metric(const_cast<MyQWebEngineView*>(this), metric); };
QPaintEngine * paintEngine() const { return static_cast<QPaintEngine*>(callbackQWebEngineView_PaintEngine(const_cast<MyQWebEngineView*>(this))); };
};
void* QWebEngineView_NewQWebEngineView(void* parent)
@ -3623,3 +3627,23 @@ void* QWebEngineView_MetaObjectDefault(void* ptr)
return const_cast<QMetaObject*>(static_cast<QWebEngineView*>(ptr)->QWebEngineView::metaObject());
}
int QWebEngineView_Metric(void* ptr, long long metric)
{
return static_cast<QWebEngineView*>(ptr)->metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
int QWebEngineView_MetricDefault(void* ptr, long long metric)
{
return static_cast<QWebEngineView*>(ptr)->QWebEngineView::metric(static_cast<QPaintDevice::PaintDeviceMetric>(metric));
}
void* QWebEngineView_PaintEngine(void* ptr)
{
return static_cast<QWebEngineView*>(ptr)->paintEngine();
}
void* QWebEngineView_PaintEngineDefault(void* ptr)
{
return static_cast<QWebEngineView*>(ptr)->QWebEngineView::paintEngine();
}

View file

@ -9660,6 +9660,82 @@ func (ptr *QWebEngineView) MetaObjectDefault() *core.QMetaObject {
return nil
}
//export callbackQWebEngineView_Metric
func callbackQWebEngineView_Metric(ptr unsafe.Pointer, metric C.longlong) C.int {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QWebEngineView::metric"); signal != nil {
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
return C.int(int32(NewQWebEngineViewFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(metric))))
}
func (ptr *QWebEngineView) ConnectMetric(f func(metric gui.QPaintDevice__PaintDeviceMetric) int) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QWebEngineView::metric", f)
}
}
func (ptr *QWebEngineView) DisconnectMetric() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QWebEngineView::metric")
}
}
func (ptr *QWebEngineView) Metric(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QWebEngineView_Metric(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
func (ptr *QWebEngineView) MetricDefault(metric gui.QPaintDevice__PaintDeviceMetric) int {
if ptr.Pointer() != nil {
return int(int32(C.QWebEngineView_MetricDefault(ptr.Pointer(), C.longlong(metric))))
}
return 0
}
//export callbackQWebEngineView_PaintEngine
func callbackQWebEngineView_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
if signal := qt.GetSignal(fmt.Sprint(ptr), "QWebEngineView::paintEngine"); signal != nil {
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
}
return gui.PointerFromQPaintEngine(NewQWebEngineViewFromPointer(ptr).PaintEngineDefault())
}
func (ptr *QWebEngineView) ConnectPaintEngine(f func() *gui.QPaintEngine) {
if ptr.Pointer() != nil {
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "QWebEngineView::paintEngine", f)
}
}
func (ptr *QWebEngineView) DisconnectPaintEngine() {
if ptr.Pointer() != nil {
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "QWebEngineView::paintEngine")
}
}
func (ptr *QWebEngineView) PaintEngine() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QWebEngineView_PaintEngine(ptr.Pointer()))
}
return nil
}
func (ptr *QWebEngineView) PaintEngineDefault() *gui.QPaintEngine {
if ptr.Pointer() != nil {
return gui.NewQPaintEngineFromPointer(C.QWebEngineView_PaintEngineDefault(ptr.Pointer()))
}
return nil
}
//QtWebEngineCore::TextureTarget
type QtWebEngineCore__TextureTarget int64

View file

@ -676,6 +676,10 @@ char QWebEngineView_EventFilter(void* ptr, void* watched, void* event);
char QWebEngineView_EventFilterDefault(void* ptr, void* watched, void* event);
void* QWebEngineView_MetaObject(void* ptr);
void* QWebEngineView_MetaObjectDefault(void* ptr);
int QWebEngineView_Metric(void* ptr, long long metric);
int QWebEngineView_MetricDefault(void* ptr, long long metric);
void* QWebEngineView_PaintEngine(void* ptr);
void* QWebEngineView_PaintEngineDefault(void* ptr);
#ifdef __cplusplus
}

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff