paweld/lazarus
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/lazarus/lazarus.git synced 2025-09-13 13:19:18 +02:00
Code Issues Packages Projects Releases Wiki Activity

Qt5: cbindings - implemented QMargins, QSurface, QSurfaceFormat, QBackingStore, QScreen and QWindow classes.

Browse Source 
git-svn-id: trunk@54941 -
This commit is contained in:
zeljko 2017-05-16 17:21:34 +00:00
parent 02709b7716
commit bc5b9b84fc
21 changed files with 2260 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
.gitattributes vendored
View File

@ -8059,6 +8059,8 @@ lcl/interfaces/qt5/cbindings/src/qapplication_hook_c.cpp svneol=native#text/plai
lcl/interfaces/qt5/cbindings/src/qapplication_hook_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qauthenticator_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qauthenticator_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qbackingstore_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qbackingstore_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qbitmap_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qbitmap_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qboxlayout_c.cpp svneol=native#text/plain
@ -8294,6 +8296,8 @@ lcl/interfaces/qt5/cbindings/src/qmainwindow_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmainwindow_hook.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmainwindow_hook_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmainwindow_hook_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmargins_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmargins_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmatrix_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmatrix_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qmdiarea_c.cpp svneol=native#text/plain
@ -8419,6 +8423,11 @@ lcl/interfaces/qt5/cbindings/src/qregion_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qregion_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qrubberband_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qrubberband_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscreen_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscreen_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscreen_hook.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscreen_hook_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscreen_hook_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscrollarea_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscrollarea_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qscrollbar_c.cpp svneol=native#text/plain
@ -8501,6 +8510,10 @@ lcl/interfaces/qt5/cbindings/src/qstylefactory_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qstylefactory_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qstyleoption_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qstyleoption_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qsurface_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qsurface_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qsurfaceformat_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qsurfaceformat_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qsystemtrayicon_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qsystemtrayicon_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qsystemtrayicon_hook.h svneol=native#text/plain
@ -8669,6 +8682,11 @@ lcl/interfaces/qt5/cbindings/src/qwidget_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwidget_hook.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwidget_hook_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwidget_hook_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwindow_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwindow_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwindow_hook.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwindow_hook_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qwindow_hook_c.h svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qx11info_x11_c.cpp svneol=native#text/plain
lcl/interfaces/qt5/cbindings/src/qx11info_x11_c.h svneol=native#text/plain
lcl/interfaces/qt5/interfaces.pp svneol=native#text/plain

18
lcl/interfaces/qt5/cbindings/Qt5Pas.pro
View File

@ -117,7 +117,10 @@ HEADERS += \
qsize_c.h \
qstring_c.h \
qstringlist_c.h \
qsurface_c.h \
qsurfaceformat_c.h \
qrect_c.h \
qmargins_c.h \
qdatetime_c.h \
qbytearray_c.h \
qlocale_c.h \
@ -149,6 +152,10 @@ HEADERS += \
qapplication_hook.h \
qwhatsthis_c.h \
qsizepolicy_c.h \
qscreen_c.h \
qscreen_hook.h \
qwindow_c.h \
qwindow_hook.h \
qwidget_c.h \
qwidget_hook.h \
qlayoutitem_c.h \
@ -175,6 +182,7 @@ HEADERS += \
qbrush_c.h \
qpen_c.h \
qpolygon_c.h \
qbackingstore_c.h \
qpainter_c.h \
qpaintengine_c.h \
qpaintdevice_c.h \
@ -371,6 +379,8 @@ HEADERS += \
qdrag_hook_c.h \
qguiapplication_hook_c.h \
qapplication_hook_c.h \
qscreen_hook_c.h \
qwindow_hook_c.h \
qwidget_hook_c.h \
qlayout_hook_c.h \
qstackedlayout_hook_c.h \
@ -464,7 +474,10 @@ SOURCES += \
qsize_c.cpp \
qstring_c.cpp \
qstringlist_c.cpp \
qsurface_c.cpp \
qsurfaceformat_c.cpp \
qrect_c.cpp \
qmargins_c.cpp \
qdatetime_c.cpp \
qbytearray_c.cpp \
qlocale_c.cpp \
@ -489,6 +502,8 @@ SOURCES += \
qapplication_c.cpp \
qwhatsthis_c.cpp \
qsizepolicy_c.cpp \
qscreen_c.cpp \
qwindow_c.cpp \
qwidget_c.cpp \
qlayoutitem_c.cpp \
qlayout_c.cpp \
@ -508,6 +523,7 @@ SOURCES += \
qbrush_c.cpp \
qpen_c.cpp \
qpolygon_c.cpp \
qbackingstore_c.cpp \
qpainter_c.cpp \
qpaintengine_c.cpp \
qpaintdevice_c.cpp \
@ -642,6 +658,8 @@ SOURCES += \
qdrag_hook_c.cpp \
qguiapplication_hook_c.cpp \
qapplication_hook_c.cpp \
qscreen_hook_c.cpp \
qwindow_hook_c.cpp \
qwidget_hook_c.cpp \
qlayout_hook_c.cpp \
qstackedlayout_hook_c.cpp \

4
lcl/interfaces/qt5/cbindings/src/chandles.h
View File

@ -23,6 +23,8 @@ typedef unsigned int PTRUINT;
typedef struct QAbstractButton__ { PTRINT dummy; } *QAbstractButtonH;
typedef struct QSizePolicy__ { PTRINT dummy; } *QSizePolicyH;
typedef struct QSurface__ { PTRINT dummy; } *QSurfaceH;
typedef struct QSurfaceFormat__ { PTRINT dummy; } *QSurfaceFormatH;
/* typedef struct QWebHistoryItem_hook__ { PTRINT dummy; } *QWebHistoryItem_hookH; */
typedef struct QSlider_hook__ { PTRINT dummy; } *QSlider_hookH;
typedef struct QGraphicsScene_hook__ { PTRINT dummy; } *QGraphicsScene_hookH;
@ -446,6 +448,8 @@ typedef struct QButtonGroup_hook__ { PTRINT dummy; } *QButtonGroup_hookH;
typedef struct QInputMethodEvent__ { PTRINT dummy; } *QInputMethodEventH;
typedef struct QDate__ { PTRINT dummy; } *QDateH;
typedef struct QStyleOptionTitleBar__ { PTRINT dummy; } *QStyleOptionTitleBarH;
typedef struct QScreen_hook__ { PTRINT dummy; } *QScreen_hookH;
typedef struct QWindow_hook__ { PTRINT dummy; } *QWindow_hookH;
typedef struct QWidget_hook__ { PTRINT dummy; } *QWidget_hookH;
typedef struct QDockWidget__ { PTRINT dummy; } *QDockWidgetH;
typedef struct QLine__ { PTRINT dummy; } *QLineH;

78
lcl/interfaces/qt5/cbindings/src/qbackingstore_c.cpp Normal file
View File

@ -0,0 +1,78 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qbackingstore_c.h"
QBackingStoreH QBackingStore_Create(QWindowH window)
{
return (QBackingStoreH) new QBackingStore((QWindow*)window);
}
void QBackingStore_Destroy(QBackingStoreH handle)
{
delete (QBackingStore *)handle;
}
QWindowH QBackingStore_window(QBackingStoreH handle)
{
return (QWindowH) ((QBackingStore *)handle)->window();
}
QPaintDeviceH QBackingStore_paintDevice(QBackingStoreH handle)
{
return (QPaintDeviceH) ((QBackingStore *)handle)->paintDevice();
}
void QBackingStore_flush(QBackingStoreH handle, const QRegionH region, QWindowH window, const QPointH offset)
{
((QBackingStore *)handle)->flush(*(const QRegion*) region, (QWindow *)window, *(const QPoint*) offset);
}
void QBackingStore_resize(QBackingStoreH handle, const QSizeH AnonParam1)
{
((QBackingStore *)handle)->resize(*(const QSize*)AnonParam1);
}
void QBackingStore_size(QBackingStoreH handle, PSize retval)
{
*(QSize *)retval = ((QBackingStore *)handle)->size();
}
bool QBackingStore_scroll(QBackingStoreH handle, const QRegionH area, int dx, int dy)
{
((QBackingStore *)handle)->scroll(*(const QRegion*)area, dx, dy);
}
void QBackingStore_beginPaint(QBackingStoreH handle, const QRegionH AnonParam1)
{
((QBackingStore *)handle)->beginPaint(*(const QRegion*)AnonParam1);
}
void QBackingStore_endPaint(QBackingStoreH handle)
{
((QBackingStore *)handle)->endPaint();
}
void QBackingStore_setStaticContents(QBackingStoreH handle, const QRegionH AnonParam1)
{
((QBackingStore *)handle)->setStaticContents(*(const QRegion*)AnonParam1);
}
void QBackingStore_staticContents(QBackingStoreH handle, QRegionH retval)
{
*(QRegion *)retval = ((QBackingStore *)handle)->staticContents();
}
bool QBackingStore_hasStaticContents(QBackingStoreH handle)
{
return (bool) ((QBackingStore *)handle)->hasStaticContents();
}

32
lcl/interfaces/qt5/cbindings/src/qbackingstore_c.h Normal file
View File

@ -0,0 +1,32 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QBACKINGSTORE_C_H
#define QBACKINGSTORE_C_H
#include <QtGui>
#include "pascalbind.h"
C_EXPORT QBackingStoreH QBackingStore_Create(QWindowH window);
C_EXPORT void QBackingStore_Destroy(QBackingStoreH handle);
C_EXPORT QWindowH QBackingStore_window(QBackingStoreH handle);
C_EXPORT QPaintDeviceH QBackingStore_paintDevice(QBackingStoreH handle);
C_EXPORT void QBackingStore_flush(QBackingStoreH handle, const QRegionH region, QWindowH window, const QPointH offset);
C_EXPORT void QBackingStore_resize(QBackingStoreH handle, const QSizeH AnonParam1);
C_EXPORT void QBackingStore_size(QBackingStoreH handle, PSize retval);
C_EXPORT bool QBackingStore_scroll(QBackingStoreH handle, const QRegionH area, int dx, int dy);
C_EXPORT void QBackingStore_beginPaint(QBackingStoreH handle, const QRegionH AnonParam1);
C_EXPORT void QBackingStore_endPaint(QBackingStoreH handle);
C_EXPORT void QBackingStore_setStaticContents(QBackingStoreH handle, const QRegionH AnonParam1);
C_EXPORT void QBackingStore_staticContents(QBackingStoreH handle, QRegionH retval);
C_EXPORT bool QBackingStore_hasStaticContents(QBackingStoreH handle);
#endif

73
lcl/interfaces/qt5/cbindings/src/qmargins_c.cpp Normal file
View File

@ -0,0 +1,73 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qmargins_c.h"
QMarginsH QMargins_Create()
{
return (QMarginsH) new QMargins();
}
QMarginsH QMargins_Create2(int left, int top, int right, int bottom)
{
return (QMarginsH) new QMargins(left, top, right, bottom);
}
void QMargins_Destroy(QMarginsH handle)
{
delete (QMargins *)handle;
}
bool QMargins_isNull(QMarginsH handle)
{
return (bool) ((QMargins *)handle)->isNull();
}
int QMargins_left(QMarginsH handle)
{
return (int) ((QMargins *)handle)->left();
}
int QMargins_top(QMarginsH handle)
{
return (int) ((QMargins *)handle)->top();
}
int QMargins_right(QMarginsH handle)
{
return (int) ((QMargins *)handle)->right();
}
int QMargins_bottom(QMarginsH handle)
{
return (int) ((QMargins *)handle)->bottom();
}
void QMargins_setLeft(QMarginsH handle, int left)
{
((QMargins *)handle)->setLeft(left);
}
void QMargins_setTop(QMarginsH handle, int top)
{
((QMargins *)handle)->setTop(top);
}
void QMargins_setRight(QMarginsH handle, int right)
{
((QMargins *)handle)->setRight(right);
}
void QMargins_setBottom(QMarginsH handle, int bottom)
{
((QMargins *)handle)->setBottom(bottom);
}

31
lcl/interfaces/qt5/cbindings/src/qmargins_c.h Normal file
View File

@ -0,0 +1,31 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QMARGINS_C_H
#define QMARGINS_C_H
#include <QtCore>
#include "pascalbind.h"
C_EXPORT QMarginsH QMargins_Create();
C_EXPORT QMarginsH QMargins_Create2(int left, int top, int right, int bottom);
C_EXPORT void QMargins_Destroy(QMarginsH handle);
C_EXPORT bool QMargins_isNull(QMarginsH handle);
C_EXPORT int QMargins_left(QMarginsH handle);
C_EXPORT int QMargins_top(QMarginsH handle);
C_EXPORT int QMargins_right(QMarginsH handle);
C_EXPORT int QMargins_bottom(QMarginsH handle);
C_EXPORT void QMargins_setLeft(QMarginsH handle, int left);
C_EXPORT void QMargins_setTop(QMarginsH handle, int top);
C_EXPORT void QMargins_setRight(QMarginsH handle, int right);
C_EXPORT void QMargins_setBottom(QMarginsH handle, int bottom);
#endif

178
lcl/interfaces/qt5/cbindings/src/qscreen_c.cpp Normal file
View File

@ -0,0 +1,178 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qscreen_c.h"
void QScreen_Destroy(QScreenH handle)
{
delete (QScreen *)handle;
}
void QScreen_name(QScreenH handle, PWideString retval)
{
QString t_retval;
t_retval = ((QScreen *)handle)->name();
copyQStringToPWideString(t_retval, retval);
}
int QScreen_depth(QScreenH handle)
{
return (int) ((QScreen *)handle)->depth();
}
void QScreen_size(QScreenH handle, PSize retval)
{
*(QSize *)retval = ((QScreen *)handle)->size();
}
void QScreen_geometry(QScreenH handle, PRect retval)
{
QRect t_retval;
t_retval = ((QScreen *)handle)->geometry();
copyQRectToPRect(t_retval, retval);
}
void QScreen_physicalSize(QScreenH handle, QSizeFH retval)
{
*(QSizeF *)retval = ((QScreen *)handle)->physicalSize();
}
qreal QScreen_physicalDotsPerInchX(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->physicalDotsPerInchX();
}
qreal QScreen_physicalDotsPerInchY(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->physicalDotsPerInchY();
}
qreal QScreen_physicalDotsPerInch(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->physicalDotsPerInch();
}
qreal QScreen_logicalDotsPerInchX(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->logicalDotsPerInchX();
}
qreal QScreen_logicalDotsPerInchY(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->logicalDotsPerInchY();
}
qreal QScreen_logicalDotsPerInch(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->logicalDotsPerInch();
}
qreal QScreen_devicePixelRatio(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->devicePixelRatio();
}
void QScreen_availableSize(QScreenH handle, PSize retval)
{
*(QSize *)retval = ((QScreen *)handle)->availableSize();
}
void QScreen_availableGeometry(QScreenH handle, PRect retval)
{
QRect t_retval;
t_retval = ((QScreen *)handle)->availableGeometry();
copyQRectToPRect(t_retval, retval);
}
void QScreen_virtualSize(QScreenH handle, PSize retval)
{
*(QSize *)retval = ((QScreen *)handle)->virtualSize();
}
void QScreen_virtualGeometry(QScreenH handle, PRect retval)
{
QRect t_retval;
t_retval = ((QScreen *)handle)->virtualGeometry();
copyQRectToPRect(t_retval, retval);
}
Qt::ScreenOrientation QScreen_primaryOrientation(QScreenH handle)
{
return (Qt::ScreenOrientation) ((QScreen *)handle)->primaryOrientation();
}
Qt::ScreenOrientation QScreen_orientation(QScreenH handle)
{
return (Qt::ScreenOrientation) ((QScreen *)handle)->orientation();
}
Qt::ScreenOrientation QScreen_nativeOrientation(QScreenH handle)
{
return (Qt::ScreenOrientation) ((QScreen *)handle)->nativeOrientation();
}
Qt::ScreenOrientations QScreen_orientationUpdateMask(QScreenH handle)
{
return (Qt::ScreenOrientations) ((QScreen *)handle)->orientationUpdateMask();
}
void QScreen_setOrientationUpdateMask(QScreenH handle, Qt::ScreenOrientations mask)
{
((QScreen *)handle)->setOrientationUpdateMask((Qt::ScreenOrientations) mask);
}
int QScreen_angleBetween(QScreenH handle, Qt::ScreenOrientation a, Qt::ScreenOrientation b)
{
return (int) ((QScreen *)handle)->angleBetween((Qt::ScreenOrientation) a, (Qt::ScreenOrientation) b);
}
void QScreen_virtualSiblings(QScreenH handle, PPtrIntArray retval)
{
QList<QScreen*> t_retval;
t_retval = ((QScreen *)handle)->virtualSiblings();
copyQListTemplateToPtrIntArray(t_retval, retval);
}
void QScreen_transformBetween(QScreenH handle, QTransformH retval, Qt::ScreenOrientation a, Qt::ScreenOrientation b, PRect AnonParam1)
{
QRect t_AnonParam1;
copyPRectToQRect(AnonParam1, t_AnonParam1);
*(QTransform *)retval = ((QScreen *)handle)->transformBetween((Qt::ScreenOrientation) a, (Qt::ScreenOrientation) b, t_AnonParam1);
}
void QScreen_mapBetween(QScreenH handle, PRect retval, Qt::ScreenOrientation a, Qt::ScreenOrientation b, PRect AnonParam1)
{
QRect t_AnonParam1;
QRect t_retval;
copyPRectToQRect(AnonParam1, t_AnonParam1);
t_retval = ((QScreen *)handle)->mapBetween((Qt::ScreenOrientation) a, (Qt::ScreenOrientation) b, t_AnonParam1);
copyQRectToPRect(t_retval, retval);
}
bool QScreen_isPortrait(QScreenH handle, Qt::ScreenOrientation orientation)
{
return (bool) ((QScreen *)handle)->isPortrait((Qt::ScreenOrientation) orientation);
}
bool QScreen_isLandscape(QScreenH handle, Qt::ScreenOrientation orientation)
{
return (bool) ((QScreen *)handle)->isLandscape((Qt::ScreenOrientation) orientation);
}
void QScreen_grabWindow(QScreenH handle, QPixmapH retval,unsigned int window, int x,int y,int w, int h)
{
*(QPixmap *)retval = ((QScreen *)handle)->grabWindow((WId) window, x, y, w, h);
}
qreal QScreen_refreshRate(QScreenH handle)
{
return (qreal) ((QScreen *)handle)->refreshRate();
}

49
lcl/interfaces/qt5/cbindings/src/qscreen_c.h Normal file
View File

@ -0,0 +1,49 @@
//******************************************************************************
// Copyright (c) 2007 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QSCREEN_C_H
#define QSCREEN_C_H
#include <QtGui>
#include "pascalbind.h"
C_EXPORT void QScreen_Destroy(QScreenH handle);
C_EXPORT void QScreen_name(QScreenH handle, PWideString retval);
C_EXPORT int QScreen_depth(QScreenH handle);
C_EXPORT void QScreen_size(QScreenH handle, PSize retval);
C_EXPORT void QScreen_geometry(QScreenH handle, PRect retval);
C_EXPORT void QScreen_physicalSize(QScreenH handle, QSizeFH retval);
C_EXPORT qreal QScreen_physicalDotsPerInchX(QScreenH handle);
C_EXPORT qreal QScreen_physicalDotsPerInchY(QScreenH handle);
C_EXPORT qreal QScreen_physicalDotsPerInch(QScreenH handle);
C_EXPORT qreal QScreen_logicalDotsPerInchX(QScreenH handle);
C_EXPORT qreal QScreen_logicalDotsPerInchY(QScreenH handle);
C_EXPORT qreal QScreen_logicalDotsPerInch(QScreenH handle);
C_EXPORT qreal QScreen_devicePixelRatio(QScreenH handle);
C_EXPORT void QScreen_availableSize(QScreenH handle, PSize retval);
C_EXPORT void QScreen_availableGeometry(QScreenH handle, PRect retval);
C_EXPORT void QScreen_virtualSize(QScreenH handle, PSize retval);
C_EXPORT void QScreen_virtualGeometry(QScreenH handle, PRect retval);
C_EXPORT Qt::ScreenOrientation QScreen_primaryOrientation(QScreenH handle);
C_EXPORT Qt::ScreenOrientation QScreen_orientation(QScreenH handle);
C_EXPORT Qt::ScreenOrientation QScreen_nativeOrientation(QScreenH handle);
C_EXPORT Qt::ScreenOrientations QScreen_orientationUpdateMask(QScreenH handle);
C_EXPORT void QScreen_setOrientationUpdateMask(QScreenH handle, Qt::ScreenOrientations mask);
C_EXPORT int QScreen_angleBetween(QScreenH handle, Qt::ScreenOrientation a, Qt::ScreenOrientation b);
C_EXPORT void QScreen_virtualSiblings(QScreenH handle, PPtrIntArray retval);
C_EXPORT void QScreen_transformBetween(QScreenH handle, QTransformH retval, Qt::ScreenOrientation a, Qt::ScreenOrientation b, PRect AnonParam1);
C_EXPORT void QScreen_mapBetween(QScreenH handle, PRect retval, Qt::ScreenOrientation a, Qt::ScreenOrientation b, PRect AnonParam1);
C_EXPORT bool QScreen_isPortrait(QScreenH handle, Qt::ScreenOrientation orientation);
C_EXPORT bool QScreen_isLandscape(QScreenH handle, Qt::ScreenOrientation orientation);
C_EXPORT void QScreen_grabWindow(QScreenH handle, QPixmapH retval,unsigned int window, int x = 0,int y = 0,int w = -1, int h = -1);
C_EXPORT qreal QScreen_refreshRate(QScreenH handle);
#endif

190
lcl/interfaces/qt5/cbindings/src/qscreen_hook.h Normal file
View File

@ -0,0 +1,190 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QSCREEN_HOOK_H
#define QSCREEN_HOOK_H
#include <qscreen.h>
#include "qobject_hook.h"
class QScreen_hook : public QObject_hook {
Q_OBJECT
public:
QScreen_hook(QObject *handle) : QObject_hook(handle) {
geometryChanged_event.func = NULL;
availableGeometryChanged_event.func = NULL;
physicalSizeChanged_event.func = NULL;
physicalDotsPerInchChanged_event.func = NULL;
logicalDotsPerInchChanged_event.func = NULL;
virtualGeometryChanged_event.func = NULL;
primaryOrientationChanged_event.func = NULL;
orientationChanged_event.func = NULL;
refreshRateChanged_event.func = NULL;
}
void hook_geometryChanged(QHook &hook) {
if ( !geometryChanged_event.func )
connect(handle, SIGNAL(geometryChanged(const QRect&)), this, SLOT(geometryChanged_hook(const QRect&)));
geometryChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(geometryChanged(const QRect&)), this, SLOT(geometryChanged_hook(const QRect&)));
}
void hook_availableGeometryChanged(QHook &hook) {
if ( !availableGeometryChanged_event.func )
connect(handle, SIGNAL(availableGeometryChanged(const QRect&)), this, SLOT(availableGeometryChanged_hook(const QRect&)));
availableGeometryChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(availableGeometryChanged(const QRect&)), this, SLOT(availableGeometryChanged_hook(const QRect&)));
}
void hook_physicalSizeChanged(QHook &hook) {
if ( !physicalSizeChanged_event.func )
connect(handle, SIGNAL(physicalSizeChanged(const QSizeF&)), this, SLOT(physicalSizeChanged_hook(const QSizeF&)));
physicalSizeChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(physicalSizeChanged(const QSizeF&)), this, SLOT(physicalSizeChanged_hook(const QSizeF&)));
}
void hook_physicalDotsPerInchChanged(QHook &hook) {
if ( !physicalDotsPerInchChanged_event.func )
connect(handle, SIGNAL(physicalDotsPerInchChanged(qreal)), this, SLOT(physicalDotsPerInchChanged_hook(qreal)));
physicalDotsPerInchChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(physicalDotsPerInchChanged(qreal)), this, SLOT(physicalDotsPerInchChanged_hook(qreal)));
}
void hook_logicalDotsPerInchChanged(QHook &hook) {
if ( !logicalDotsPerInchChanged_event.func )
connect(handle, SIGNAL(logicalDotsPerInchChanged(qreal)), this, SLOT(logicalDotsPerInchChanged_hook(qreal)));
logicalDotsPerInchChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(logicalDotsPerInchChanged(qreal)), this, SLOT(logicalDotsPerInchChanged_hook(qreal)));
}
void hook_virtualGeometryChanged(QHook &hook) {
if ( !virtualGeometryChanged_event.func )
connect(handle, SIGNAL(virtualGeometryChanged(const QRect&)), this, SLOT(virtualGeometryChanged_hook(const QRect&)));
virtualGeometryChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(virtualGeometryChanged(const QRect&)), this, SLOT(virtualGeometryChanged_hook(const QRect&)));
}
void hook_primaryOrientationChanged(QHook &hook) {
if ( !primaryOrientationChanged_event.func )
connect(handle, SIGNAL(primaryOrientationChanged(Qt::ScreenOrientation)), this, SLOT(primaryOrientationChanged_hook(Qt::ScreenOrientation)));
primaryOrientationChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(primaryOrientationChanged(Qt::ScreenOrientation)), this, SLOT(primaryOrientationChanged_hook(Qt::ScreenOrientation)));
}
void hook_orientationChanged(QHook &hook) {
if ( !orientationChanged_event.func )
connect(handle, SIGNAL(orientationChanged(Qt::ScreenOrientation)), this, SLOT(orientationChanged_hook(Qt::ScreenOrientation)));
orientationChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(orientationChanged(Qt::ScreenOrientation)), this, SLOT(orientationChanged_hook(Qt::ScreenOrientation)));
}
void hook_refreshRateChanged(QHook &hook) {
if ( !refreshRateChanged_event.func )
connect(handle, SIGNAL(refreshRateChanged(qreal)), this, SLOT(refreshRateChanged_hook(qreal)));
refreshRateChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(refreshRateChanged(qreal)), this, SLOT(refreshRateChanged_hook(qreal)));
}
private slots:
void geometryChanged_hook(const QRect& geom) {
if ( geometryChanged_event.func ) {
typedef void (*func_type)(void *data, PRect geom);
PRect t_geom;
copyQRectToPRect(geom, t_geom);
(*(func_type)geometryChanged_event.func)(geometryChanged_event.data, t_geom);
}
}
void availableGeometryChanged_hook(const QRect& geom) {
if ( availableGeometryChanged_event.func ) {
typedef void (*func_type)(void *data, PRect geom);
PRect t_geom;
copyQRectToPRect(geom, t_geom);
(*(func_type)availableGeometryChanged_event.func)(availableGeometryChanged_event.data, t_geom);
}
}
void physicalSizeChanged_hook(const QSizeF& pos) {
if ( physicalSizeChanged_event.func ) {
typedef void (*func_type)(void *data, const QSizeFH pos);
(*(func_type)physicalSizeChanged_event.func)(physicalSizeChanged_event.data, (const QSizeFH)&pos);
}
}
void physicalDotsPerInchChanged_hook(qreal dpi) {
if ( physicalDotsPerInchChanged_event.func ) {
typedef void (*func_type)(void *data, qreal dpi);
(*(func_type)physicalDotsPerInchChanged_event.func)(physicalDotsPerInchChanged_event.data, dpi);
}
}
void logicalDotsPerInchChanged_hook(qreal dpi) {
if ( logicalDotsPerInchChanged_event.func ) {
typedef void (*func_type)(void *data, qreal dpi);
(*(func_type)logicalDotsPerInchChanged_event.func)(logicalDotsPerInchChanged_event.data, dpi);
}
}
void virtualGeometryChanged_hook(const QRect& geom) {
if ( virtualGeometryChanged_event.func ) {
typedef void (*func_type)(void *data, PRect geom);
PRect t_geom;
copyQRectToPRect(geom, t_geom);
(*(func_type)virtualGeometryChanged_event.func)(virtualGeometryChanged_event.data, t_geom);
}
}
void primaryOrientationChanged_hook(Qt::ScreenOrientation orientation) {
if ( primaryOrientationChanged_event.func ) {
typedef void (*func_type)(void *data, Qt::ScreenOrientation orientation);
(*(func_type)primaryOrientationChanged_event.func)(primaryOrientationChanged_event.data, orientation);
}
}
void orientationChanged_hook(Qt::ScreenOrientation orientation) {
if ( orientationChanged_event.func ) {
typedef void (*func_type)(void *data, Qt::ScreenOrientation orientation);
(*(func_type)orientationChanged_event.func)(orientationChanged_event.data, orientation);
}
}
void refreshRateChanged_hook(qreal refreshRate) {
if ( refreshRateChanged_event.func ) {
typedef void (*func_type)(void *data, qreal refreshRate);
(*(func_type)refreshRateChanged_event.func)(refreshRateChanged_event.data, refreshRate);
}
}
private:
QHook geometryChanged_event;
QHook availableGeometryChanged_event;
QHook physicalSizeChanged_event;
QHook physicalDotsPerInchChanged_event;
QHook logicalDotsPerInchChanged_event;
QHook virtualGeometryChanged_event;
QHook primaryOrientationChanged_event;
QHook orientationChanged_event;
QHook refreshRateChanged_event;
};
#endif

68
lcl/interfaces/qt5/cbindings/src/qscreen_hook_c.cpp Normal file
View File

@ -0,0 +1,68 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qscreen_hook_c.h"
QScreen_hookH QScreen_hook_Create(QObjectH handle)
{
return (QScreen_hookH) new QScreen_hook((QObject*)handle);
}
void QScreen_hook_Destroy(QScreen_hookH handle)
{
delete (QScreen_hook *)handle;
}
void QScreen_hook_hook_geometryChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_geometryChanged(hook);
}
void QScreen_hook_hook_availableGeometryChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_availableGeometryChanged(hook);
}
void QScreen_hook_hook_physicalSizeChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_physicalSizeChanged(hook);
}
void QScreen_hook_hook_physicalDotsPerInchChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_physicalDotsPerInchChanged(hook);
}
void QScreen_hook_hook_logicalDotsPerInchChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_logicalDotsPerInchChanged(hook);
}
void QScreen_hook_hook_virtualGeometryChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_virtualGeometryChanged(hook);
}
void QScreen_hook_hook_primaryOrientationChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_primaryOrientationChanged(hook);
}
void QScreen_hook_hook_orientationChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_orientationChanged(hook);
}
void QScreen_hook_hook_refreshRateChanged(QScreen_hookH handle, QHookH hook)
{
((QScreen_hook *)handle)->hook_refreshRateChanged(hook);
}

30
lcl/interfaces/qt5/cbindings/src/qscreen_hook_c.h Normal file
View File

@ -0,0 +1,30 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QSCREEN_HOOK_C_H
#define QSCREEN_HOOK_C_H
#include "qscreen_hook.h"
C_EXPORT QScreen_hookH QScreen_hook_Create(QObjectH handle);
C_EXPORT void QScreen_hook_Destroy(QScreen_hookH handle);
C_EXPORT void QScreen_hook_hook_geometryChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_availableGeometryChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_physicalSizeChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_physicalDotsPerInchChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_logicalDotsPerInchChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_virtualGeometryChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_primaryOrientationChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_orientationChanged(QScreen_hookH handle, QHookH hook);
C_EXPORT void QScreen_hook_hook_refreshRateChanged(QScreen_hookH handle, QHookH hook);
#endif

45
lcl/interfaces/qt5/cbindings/src/qsurface_c.cpp Normal file
View File

@ -0,0 +1,45 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qsurface_c.h"
void QSurface_Destroy(QSurfaceH handle)
{
delete (QSurface *)handle;
}
void QSurface_size(QSurfaceH handle, PSize retval)
{
*(QSize *)retval = ((QSurface *)handle)->size();
}
bool QSurface_supportsOpenGL(QSurfaceH handle)
{
return (bool) ((QSurface *)handle)->supportsOpenGL();
}
QSurface::SurfaceClass QSurface_surfaceClass(QSurfaceH handle)
{
return (QSurface::SurfaceClass) ((QSurface *)handle)->surfaceClass();
}
QSurface::SurfaceType QSurface_surfaceType(QSurfaceH handle)
{
return (QSurface::SurfaceType) ((QSurface *)handle)->surfaceType();
}
void QSurface_format(QSurfaceH handle, QSurfaceFormatH areturn)
{
*(QSurfaceFormat *)areturn = ((QSurface *)handle)->format();
}

25
lcl/interfaces/qt5/cbindings/src/qsurface_c.h Normal file
View File

@ -0,0 +1,25 @@
//******************************************************************************
// Copyright (c) 2007 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QSURFACE_C_H
#define QSURFACE_C_H
#include <QtGui>
#include "pascalbind.h"
C_EXPORT void QSurface_Destroy(QSurfaceH handle);
C_EXPORT void QSurface_size(QSurfaceH handle, PSize retval);
C_EXPORT bool QSurface_supportsOpenGL(QSurfaceH handle);
C_EXPORT QSurface::SurfaceClass QSurface_surfaceClass(QSurfaceH handle);
C_EXPORT QSurface::SurfaceType QSurface_surfaceType(QSurfaceH handle);
C_EXPORT void QSurface_format(QSurfaceH handle, QSurfaceFormatH areturn);
#endif

202
lcl/interfaces/qt5/cbindings/src/qsurfaceformat_c.cpp Normal file
View File

@ -0,0 +1,202 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qsurfaceformat_c.h"
QSurfaceFormatH QSurfaceFormat_Create()
{
return (QSurfaceFormatH) new QSurfaceFormat();
}
QSurfaceFormatH QSurfaceFormat_Create2(QSurfaceFormat::FormatOptions options)
{
return (QSurfaceFormatH) new QSurfaceFormat((QSurfaceFormat::FormatOptions) options);
}
void QSurfaceFormat_Destroy(QSurfaceFormatH handle)
{
delete (QSurfaceFormat *)handle;
}
void QSurfaceFormat_setDepthBufferSize(QSurfaceFormatH handle, int size)
{
((QSurfaceFormat*)handle)->setDepthBufferSize(size);
}
int QSurfaceFormat_depthBufferSize(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->depthBufferSize();
}
void QSurfaceFormat_setStencilBufferSize(QSurfaceFormatH handle, int size)
{
((QSurfaceFormat*)handle)->setStencilBufferSize(size);
}
int QSurfaceFormat_stencilBufferSize(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->stencilBufferSize();
}
void QSurfaceFormat_setRedBufferSize(QSurfaceFormatH handle, int size)
{
((QSurfaceFormat*)handle)->setRedBufferSize(size);
}
int QSurfaceFormat_redBufferSize(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->redBufferSize();
}
void QSurfaceFormat_setGreenBufferSize(QSurfaceFormatH handle, int size)
{
((QSurfaceFormat*)handle)->setGreenBufferSize(size);
}
int QSurfaceFormat_greenBufferSize(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->greenBufferSize();
}
void QSurfaceFormat_setBlueBufferSize(QSurfaceFormatH handle, int size)
{
((QSurfaceFormat*)handle)->setBlueBufferSize(size);
}
int QSurfaceFormat_blueBufferSize(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->blueBufferSize();
}
void QSurfaceFormat_setAlphaBufferSize(QSurfaceFormatH handle, int size)
{
((QSurfaceFormat*)handle)->setAlphaBufferSize(size);
}
int QSurfaceFormat_alphaBufferSize(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->alphaBufferSize();
}
void QSurfaceFormat_setSamples(QSurfaceFormatH handle, int numSamples)
{
((QSurfaceFormat*)handle)->setSamples(numSamples);
}
int QSurfaceFormat_samples(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->samples();
}
void QSurfaceFormat_setSwapBehavior(QSurfaceFormatH handle, QSurfaceFormat::SwapBehavior behavior)
{
((QSurfaceFormat*)handle)->setSwapBehavior((QSurfaceFormat::SwapBehavior) behavior);
}
QSurfaceFormat::SwapBehavior QSurfaceFormat_swapBehavior(QSurfaceFormatH handle)
{
return (QSurfaceFormat::SwapBehavior) ((QSurfaceFormat*)handle)->swapBehavior();
}
bool QSurfaceFormat_hasAlpha(QSurfaceFormatH handle)
{
return (bool) ((QSurfaceFormat*)handle)->hasAlpha();
}
void QSurfaceFormat_setProfile(QSurfaceFormatH handle, QSurfaceFormat::OpenGLContextProfile profile)
{
((QSurfaceFormat*)handle)->setProfile((QSurfaceFormat::OpenGLContextProfile) profile);
}
QSurfaceFormat::OpenGLContextProfile QSurfaceFormat_profile(QSurfaceFormatH handle)
{
return (QSurfaceFormat::OpenGLContextProfile) ((QSurfaceFormat*)handle)->profile();
}
void QSurfaceFormat_setRenderableType(QSurfaceFormatH handle, QSurfaceFormat::RenderableType type)
{
((QSurfaceFormat*)handle)->setRenderableType((QSurfaceFormat::RenderableType) type);
}
QSurfaceFormat::RenderableType QSurfaceFormat_renderableType(QSurfaceFormatH handle)
{
return (QSurfaceFormat::RenderableType) ((QSurfaceFormat*)handle)->renderableType();
}
void QSurfaceFormat_setMajorVersion(QSurfaceFormatH handle, int majorVersion)
{
((QSurfaceFormat*)handle)->setMajorVersion(majorVersion);
}
int QSurfaceFormat_majorVersion(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->majorVersion();
}
void QSurfaceFormat_setMinorVersion(QSurfaceFormatH handle, int minorVersion)
{
((QSurfaceFormat*)handle)->setMinorVersion(minorVersion);
}
int QSurfaceFormat_minorVersion(QSurfaceFormatH handle)
{
return (int) ((QSurfaceFormat*)handle)->minorVersion();
}
bool QSurfaceFormat_stereo(QSurfaceFormatH handle)
{
return (bool) ((QSurfaceFormat*)handle)->stereo();
}
void QSurfaceFormat_setStereo(QSurfaceFormatH handle, bool enable)
{
((QSurfaceFormat*)handle)->setStereo(enable);
}
void QSurfaceFormat_setOptions(QSurfaceFormatH handle, QSurfaceFormat::FormatOptions options)
{
((QSurfaceFormat*)handle)->setOptions((QSurfaceFormat::FormatOptions) options);
}
void QSurfaceFormat_setOption(QSurfaceFormatH handle, QSurfaceFormat::FormatOption option, bool on)
{
((QSurfaceFormat*)handle)->setOption((QSurfaceFormat::FormatOption) option, on);
}
bool QSurfaceFormat_testOption(QSurfaceFormatH handle, QSurfaceFormat::FormatOption option)
{
return (bool) ((QSurfaceFormat*)handle)->testOption((QSurfaceFormat::FormatOption) option);
}
QSurfaceFormat::FormatOptions QSurfaceFormat_options(QSurfaceFormatH handle)
{
return (QSurfaceFormat::FormatOptions) ((QSurfaceFormat*)handle)->options();
}
int QSurfaceFormat_swapInterval(QSurfaceFormatH handle)
{
return ((QSurfaceFormat*)handle)->swapInterval();
}
void QSurfaceFormat_setSwapInterval(QSurfaceFormatH handle, int interval)
{
((QSurfaceFormat*)handle)->setSwapInterval(interval);
}
void QSurfaceFormat_setDefaultFormat(QSurfaceFormatH format)
{
QSurfaceFormat::setDefaultFormat(*(const QSurfaceFormat*) format);
}
void QSurfaceFormat_defaultFormat(QSurfaceFormatH retval)
{
*(QSurfaceFormat*)retval = QSurfaceFormat::defaultFormat();
}

57
lcl/interfaces/qt5/cbindings/src/qsurfaceformat_c.h Normal file
View File

@ -0,0 +1,57 @@
//******************************************************************************
// Copyright (c) 2007 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QSURFACEFORMAT_C_H
#define QSURFACEFORMAT_C_H
#include <QtGui>
#include "pascalbind.h"
C_EXPORT QSurfaceFormatH QSurfaceFormat_Create();
C_EXPORT QSurfaceFormatH QSurfaceFormat_Create2(QSurfaceFormat::FormatOptions options);
C_EXPORT void QSurfaceFormat_Destroy(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setDepthBufferSize(QSurfaceFormatH handle,int size);
C_EXPORT int QSurfaceFormat_depthBufferSize(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setStencilBufferSize(QSurfaceFormatH handle, int size);
C_EXPORT int QSurfaceFormat_stencilBufferSize(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setRedBufferSize(QSurfaceFormatH handle, int size);
C_EXPORT int QSurfaceFormat_redBufferSize(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setGreenBufferSize(QSurfaceFormatH handle, int size);
C_EXPORT int QSurfaceFormat_greenBufferSize(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setBlueBufferSize(QSurfaceFormatH handle, int size);
C_EXPORT int QSurfaceFormat_blueBufferSize(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setAlphaBufferSize(QSurfaceFormatH handle, int size);
C_EXPORT int QSurfaceFormat_alphaBufferSize(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setSamples(QSurfaceFormatH handle, int numSamples);
C_EXPORT int QSurfaceFormat_samples(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setSwapBehavior(QSurfaceFormatH handle, QSurfaceFormat::SwapBehavior behavior);
C_EXPORT QSurfaceFormat::SwapBehavior QSurfaceFormat_swapBehavior(QSurfaceFormatH handle);
C_EXPORT bool QSurfaceFormat_hasAlpha(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setProfile(QSurfaceFormatH handle, QSurfaceFormat::OpenGLContextProfile profile);
C_EXPORT QSurfaceFormat::OpenGLContextProfile QSurfaceFormat_profile(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setRenderableType(QSurfaceFormatH handle, QSurfaceFormat::RenderableType type);
C_EXPORT QSurfaceFormat::RenderableType QSurfaceFormat_renderableType(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setMajorVersion(QSurfaceFormatH handle, int majorVersion);
C_EXPORT int QSurfaceFormat_majorVersion(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setMinorVersion(QSurfaceFormatH handle, int minorVersion);
C_EXPORT int QSurfaceFormat_minorVersion(QSurfaceFormatH handle);
C_EXPORT bool QSurfaceFormat_stereo(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setStereo(QSurfaceFormatH handle, bool enable);
C_EXPORT void QSurfaceFormat_setOptions(QSurfaceFormatH handle, QSurfaceFormat::FormatOptions options);
C_EXPORT void QSurfaceFormat_setOption(QSurfaceFormatH handle, QSurfaceFormat::FormatOption option, bool on = true);
C_EXPORT bool QSurfaceFormat_testOption(QSurfaceFormatH handle, QSurfaceFormat::FormatOption option);
C_EXPORT QSurfaceFormat::FormatOptions QSurfaceFormat_options(QSurfaceFormatH handle);
C_EXPORT int QSurfaceFormat_swapInterval(QSurfaceFormatH handle);
C_EXPORT void QSurfaceFormat_setSwapInterval(QSurfaceFormatH handle, int interval);
C_EXPORT void QSurfaceFormat_setDefaultFormat(QSurfaceFormatH format);
C_EXPORT void QSurfaceFormat_defaultFormat(QSurfaceFormatH retval);
#endif

548
lcl/interfaces/qt5/cbindings/src/qwindow_c.cpp Normal file
View File

@ -0,0 +1,548 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qwindow_c.h"
QWindowH QWindow_Create(QWindowH parent)
{
return (QWindowH) new QWindow((QWindow*)parent);
}
QWindowH QWindow_Create2(QScreenH screen)
{
return (QWindowH) new QWindow((QScreen*)screen);
}
void QWindow_Destroy(QWindowH handle)
{
delete (QWindow *)handle;
}
void QWindow_setSurfaceType(QWindowH handle, QSurface::SurfaceType surfaceType)
{
((QWindow *)handle)->setSurfaceType((QSurface::SurfaceType) surfaceType);
}
QSurface::SurfaceType QWindow_surfaceType(QWindowH handle)
{
return (QSurface::SurfaceType) ((QWindow *)handle)->surfaceType();
}
bool QWindow_isVisible(QWindowH handle)
{
return (bool) ((QWindow *)handle)->isVisible();
}
QWindow::Visibility QWindow_visibility(QWindowH handle)
{
return (QWindow::Visibility) ((QWindow *)handle)->visibility();
}
void QWindow_setVisibility(QWindowH handle, QWindow::Visibility v)
{
((QWindow *)handle)->setVisibility((QWindow::Visibility) v);
}
void QWindow_createPlatformResources(QWindowH handle) /* void create(); */
{
((QWindow *)handle)->create();
}
void QWindow_destroyPlatformResources(QWindowH handle) /* void destroy(); */
{
((QWindow *)handle)->destroy();
}
unsigned int QWindow_winId(QWindowH handle)
{
return (unsigned int) ((QWindow *)handle)->winId();
}
QWindowH QWindow_parent(QWindowH handle)
{
return (QWindowH) ((QWindow *)handle)->parent();
}
void QWindow_setParent(QWindowH handle, QWindowH parent)
{
((QWindow *)handle)->setParent((QWindow*)parent);
}
bool QWindow_isTopLevel(QWindowH handle)
{
return (bool) ((QWindow *)handle)->isTopLevel();
}
bool QWindow_isModal(QWindowH handle)
{
return (bool) ((QWindow *)handle)->isModal();
}
Qt::WindowModality QWindow_modality(QWindowH handle)
{
return (Qt::WindowModality) ((QWindow *)handle)->modality();
}
void QWindow_setModality(QWindowH handle, Qt::WindowModality windowModality)
{
((QWindow *)handle)->setModality((Qt::WindowModality)windowModality);
}
void QWindow_setFormat(QWindowH handle, const QSurfaceFormatH format)
{
((QWindow *)handle)->setFormat(*(const QSurfaceFormat*) format);
}
void QWindow_format(QWindowH handle, QSurfaceFormatH retval)
{
*(QSurfaceFormat*) retval = ((QWindow *)handle)->format();
}
void QWindow_requestedFormat(QWindowH handle, QSurfaceFormatH retval)
{
*(QSurfaceFormat*) retval = ((QWindow *)handle)->requestedFormat();
}
void QWindow_setFlags(QWindowH handle, unsigned int flags)
{
((QWindow *)handle)->setFlags((Qt::WindowFlags)flags);
}
unsigned int QWindow_flags(QWindowH handle)
{
return (unsigned int) ((QWindow *)handle)->flags();
}
Qt::WindowType QWindow_type(QWindowH handle)
{
return (Qt::WindowType) ((QWindow *)handle)->type();
}
void QWindow_title(QWindowH handle, PWideString retval)
{
QString t_retval;
t_retval = ((QWindow *)handle)->title();
copyQStringToPWideString(t_retval, retval);
}
void QWindow_setOpacity(QWindowH handle, qreal level)
{
((QWindow *)handle)->setOpacity(level);
}
qreal QWindow_opacity(QWindowH handle)
{
return (qreal) ((QWindow *)handle)->opacity();
}
void QWindow_setMask(QWindowH handle, const QRegionH AnonParam1)
{
((QWindow *)handle)->setMask(*(const QRegion*)AnonParam1);
}
void QWindow_mask(QWindowH handle, QRegionH retval)
{
*(QRegion *)retval = ((QWindow *)handle)->mask();
}
bool QWindow_isActiveWindow(QWindowH handle)
{
return (bool) ((QWindow *)handle)->isActive();
}
void QWindow_reportContentOrientationChange(QWindowH handle, Qt::ScreenOrientation orientation)
{
((QWindow *)handle)->reportContentOrientationChange((Qt::ScreenOrientation) orientation);
}
Qt::ScreenOrientation QWindow_contentOrientation(QWindowH handle)
{
return (Qt::ScreenOrientation) ((QWindow *)handle)->contentOrientation();
}
qreal QWindow_devicePixelRatio(QWindowH handle)
{
return (qreal) ((QWindow *)handle)->devicePixelRatio();
}
unsigned int QWindow_windowState(QWindowH handle)
{
return (unsigned int) ((QWindow *)handle)->windowState();
}
void QWindow_setWindowState(QWindowH handle, unsigned int state)
{
((QWindow *)handle)->setWindowState((Qt::WindowState)state);
}
void QWindow_setTransientParent(QWindowH handle, QWindowH parent)
{
((QWindow *)handle)->setTransientParent((QWindow*)parent);
}
QWindowH QWindow_transientParent(QWindowH handle)
{
return (QWindowH) ((QWindow *)handle)->transientParent();
}
bool QWindow_isAncestorOf(QWindowH handle, const QWindowH child, QWindow::AncestorMode mode)
{
return (bool) ((QWindow *)handle)->isAncestorOf((QWindow *)child, (QWindow::AncestorMode) mode);
}
bool QWindow_isExposed(QWindowH handle)
{
return (bool) ((QWindow *)handle)->isExposed();
}
int QWindow_minimumWidth(QWindowH handle)
{
return (int) ((QWindow *)handle)->minimumWidth();
}
int QWindow_minimumHeight(QWindowH handle)
{
return (int) ((QWindow *)handle)->minimumHeight();
}
int QWindow_maximumWidth(QWindowH handle)
{
return (int) ((QWindow *)handle)->maximumWidth();
}
int QWindow_maximumHeight(QWindowH handle)
{
return (int) ((QWindow *)handle)->maximumHeight();
}
void QWindow_minimumSize(QWindowH handle, PSize retval)
{
*(QSize *)retval = ((QWindow *)handle)->minimumSize();
}
void QWindow_maximumSize(QWindowH handle, PSize retval)
{
*(QSize *)retval = ((QWindow *)handle)->maximumSize();
}
void QWindow_baseSize(QWindowH handle, PSize retval)
{
*(QSize *)retval = ((QWindow *)handle)->baseSize();
}
void QWindow_sizeIncrement(QWindowH handle, PSize retval)
{
*(QSize *)retval = ((QWindow *)handle)->sizeIncrement();
}
void QWindow_setMinimumSize(QWindowH handle, const QSizeH AnonParam1)
{
((QWindow *)handle)->setMinimumSize(*(const QSize*)AnonParam1);
}
void QWindow_setMaximumSize(QWindowH handle, const QSizeH AnonParam1)
{
((QWindow *)handle)->setMaximumSize(*(const QSize*)AnonParam1);
}
void QWindow_setBaseSize(QWindowH handle, const QSizeH AnonParam1)
{
((QWindow *)handle)->setBaseSize(*(const QSize*)AnonParam1);
}
void QWindow_setSizeIncrement(QWindowH handle, const QSizeH AnonParam1)
{
((QWindow *)handle)->setSizeIncrement(*(const QSize*)AnonParam1);
}
void QWindow_setGeometry(QWindowH handle, int x, int y, int w, int h)
{
((QWindow *)handle)->setGeometry(x, y, w, h);
}
void QWindow_setGeometry2(QWindowH handle, PRect AnonParam1)
{
QRect t_AnonParam1;
copyPRectToQRect(AnonParam1, t_AnonParam1);
((QWindow *)handle)->setGeometry(t_AnonParam1);
}
void QWindow_geometry(QWindowH handle, PRect retval)
{
QRect t_retval;
t_retval = ((QWindow *)handle)->geometry();
copyQRectToPRect(t_retval, retval);
}
void QWindow_frameMargins(QWindowH handle, QMarginsH retval)
{
*(QMargins *)retval = ((QWindow *)handle)->frameMargins();
}
void QWindow_frameGeometry(QWindowH handle, PRect retval)
{
QRect t_retval;
t_retval = ((QWindow *)handle)->frameGeometry();
copyQRectToPRect(t_retval, retval);
}
void QWindow_framePosition(QWindowH handle, PQtPoint retval)
{
*(QPoint *)retval = ((QWindow *)handle)->framePosition();
}
void QWindow_setFramePosition(QWindowH handle, const QPointH AnonParam1)
{
((QWindow *)handle)->setFramePosition(*(const QPoint*)AnonParam1);
}
int QWindow_width(QWindowH handle)
{
return (int) ((QWindow *)handle)->width();
}
int QWindow_height(QWindowH handle)
{
return (int) ((QWindow *)handle)->height();
}
int QWindow_x(QWindowH handle)
{
return (int) ((QWindow *)handle)->x();
}
int QWindow_y(QWindowH handle)
{
return (int) ((QWindow *)handle)->y();
}
void QWindow_size(QWindowH handle, PSize retval)
{
*(QSize *)retval = ((QWindow *)handle)->size();
}
void QWindow_position(QWindowH handle, PQtPoint retval)
{
*(QPoint *)retval = ((QWindow *)handle)->position();
}
void QWindow_setPosition(QWindowH handle, const QPointH AnonParam1)
{
((QWindow *)handle)->setPosition(*(const QPoint*)AnonParam1);
}
void QWindow_setPosition2(QWindowH handle, int posx, int posy)
{
((QWindow *)handle)->setPosition(posx, posy);
}
void QWindow_resize(QWindowH handle, const QSizeH AnonParam1)
{
((QWindow *)handle)->resize(*(const QSize*)AnonParam1);
}
void QWindow_resize2(QWindowH handle, int w, int h)
{
((QWindow *)handle)->resize(w, h);
}
void QWindow_setFilePath(QWindowH handle, PWideString AnonParam1)
{
QString t_AnonParam1;
copyPWideStringToQString(AnonParam1, t_AnonParam1);
((QWindow *)handle)->setFilePath(t_AnonParam1);
}
void QWindow_filePath(QWindowH handle, PWideString retval)
{
QString t_retval;
t_retval = ((QWindow *)handle)->filePath();
copyQStringToPWideString(t_retval, retval);
}
void QWindow_setIcon(QWindowH handle, const QIconH icon)
{
((QWindow *)handle)->setIcon(*(const QIcon*)icon);
}
void QWindow_icon(QWindowH handle, QIconH retval)
{
*(QIcon *)retval = ((QWindow *)handle)->icon();
}
QScreenH QWindow_screen(QWindowH handle)
{
return (QScreenH) ((QWindow *)handle)->screen();
}
void QWindow_setScreen(QWindowH handle, QScreenH screen)
{
((QWindow *)handle)->setScreen((QScreen *) screen);
}
bool QWindow_setKeyboardGrabEnabled(QWindowH handle, bool grab)
{
((QWindow *)handle)->setKeyboardGrabEnabled(grab);
}
bool QWindow_setMouseGrabEnabled(QWindowH handle, bool grab)
{
((QWindow *)handle)->setMouseGrabEnabled(grab);
}
void QWindow_mapToGlobal(QWindowH handle, PQtPoint retval, const QPointH AnonParam1)
{
*(QPoint *)retval = ((QWindow *)handle)->mapToGlobal(*(const QPoint*)AnonParam1);
}
void QWindow_mapFromGlobal(QWindowH handle, PQtPoint retval, const QPointH AnonParam1)
{
*(QPoint *)retval = ((QWindow *)handle)->mapFromGlobal(*(const QPoint*)AnonParam1);
}
void QWindow_cursor(QWindowH handle, QCursorH retval)
{
*(QCursor *)retval = ((QWindow *)handle)->cursor();
}
void QWindow_setCursor(QWindowH handle, const QCursorH AnonParam1)
{
((QWindow *)handle)->setCursor(*(const QCursor*)AnonParam1);
}
void QWindow_unsetCursor(QWindowH handle)
{
((QWindow *)handle)->unsetCursor();
}
QObjectH QWindow_focusObject(QWindowH handle)
{
return (QObjectH) ((QWindow *)handle)->focusObject();
}
QWindowH QWindow_fromWinID(unsigned int id)
{
return (QWindowH) QWindow::fromWinId((WId) id);
}
void QWindow_requestActivate(QWindowH handle)
{
((QWindow *)handle)->requestActivate();
}
void QWindow_setVisible(QWindowH handle, bool visible)
{
((QWindow *)handle)->setVisible(visible);
}
void QWindow_show(QWindowH handle)
{
((QWindow *)handle)->show();
}
void QWindow_hide(QWindowH handle)
{
((QWindow *)handle)->hide();
}
void QWindow_showMinimized(QWindowH handle)
{
((QWindow *)handle)->showMinimized();
}
void QWindow_showMaximized(QWindowH handle)
{
((QWindow *)handle)->showMaximized();
}
void QWindow_showFullScreen(QWindowH handle)
{
((QWindow *)handle)->showFullScreen();
}
void QWindow_showNormal(QWindowH handle)
{
((QWindow *)handle)->showNormal();
}
bool QWindow_close(QWindowH handle)
{
return (bool) ((QWindow *)handle)->close();
}
void QWindow_raise(QWindowH handle)
{
((QWindow *)handle)->raise();
}
void QWindow_lower(QWindowH handle)
{
((QWindow *)handle)->lower();
}
void QWindow_setWindowTitle(QWindowH handle, PWideString AnonParam1)
{
QString t_AnonParam1;
copyPWideStringToQString(AnonParam1, t_AnonParam1);
((QWindow *)handle)->setTitle(t_AnonParam1);
}
void QWindow_setX(QWindowH handle, int argx)
{
((QWindow *)handle)->setX(argx);
}
void QWindow_setY(QWindowH handle, int argy)
{
((QWindow *)handle)->setY(argy);
}
void QWindow_setWidth(QWindowH handle, int argw)
{
((QWindow *)handle)->setWidth(argw);
}
void QWindow_setHeight(QWindowH handle, int argh)
{
((QWindow *)handle)->setHeight(argh);
}
void QWindow_setMinimumWidth(QWindowH handle, int w)
{
((QWindow *)handle)->setMinimumWidth(w);
}
void QWindow_setMinimumHeight(QWindowH handle, int h)
{
((QWindow *)handle)->setMinimumHeight(h);
}
void QWindow_setMaximumWidth(QWindowH handle, int w)
{
((QWindow *)handle)->setMaximumWidth(w);
}
void QWindow_setMaximumHeight(QWindowH handle, int h)
{
((QWindow *)handle)->setMaximumHeight(h);
}
void QWindow_alert(QWindowH handle, int msec)
{
((QWindow *)handle)->alert(msec);
}
void QWindow_requestUpdate(QWindowH handle)
{
((QWindow *)handle)->requestUpdate();
}

123
lcl/interfaces/qt5/cbindings/src/qwindow_c.h Normal file
View File

@ -0,0 +1,123 @@
//******************************************************************************
// Copyright (c) 2007 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QWINDOW_C_H
#define QWINDOW_C_H
#include <QtGui>
#include "pascalbind.h"
C_EXPORT QWindowH QWindow_Create(QWindowH parent);
C_EXPORT QWindowH QWindow_Create2(QScreenH screen = Q_NULLPTR);
C_EXPORT void QWindow_Destroy(QWindowH handle);
C_EXPORT void QWindow_setSurfaceType(QWindowH handle, QSurface::SurfaceType surfaceType);
C_EXPORT QSurface::SurfaceType QWindow_surfaceType(QWindowH handle);
C_EXPORT bool QWindow_isVisible(QWindowH handle);
C_EXPORT QWindow::Visibility QWindow_visibility(QWindowH handle);
C_EXPORT void QWindow_setVisibility(QWindowH handle, QWindow::Visibility v);
C_EXPORT void QWindow_createPlatformResources(QWindowH handle); /* void create(); */
C_EXPORT void QWindow_destroyPlatformResources(QWindowH handle); /* void destroy(); */
C_EXPORT unsigned int QWindow_winId(QWindowH handle);
C_EXPORT QWindowH QWindow_parent(QWindowH handle);
C_EXPORT void QWindow_setParent(QWindowH handle, QWindowH parent);
C_EXPORT bool QWindow_isTopLevel(QWindowH handle);
C_EXPORT bool QWindow_isModal(QWindowH handle);
C_EXPORT Qt::WindowModality QWindow_modality(QWindowH handle);
C_EXPORT void QWindow_setModality(QWindowH handle, Qt::WindowModality windowModality);
C_EXPORT void QWindow_setFormat(QWindowH handle, const QSurfaceFormatH format);
C_EXPORT void QWindow_format(QWindowH handle, QSurfaceFormatH retval);
C_EXPORT void QWindow_requestedFormat(QWindowH handle, QSurfaceFormatH retval);
C_EXPORT void QWindow_setFlags(QWindowH handle, unsigned int flags);
C_EXPORT unsigned int QWindow_flags(QWindowH handle);
C_EXPORT Qt::WindowType QWindow_type(QWindowH handle);
C_EXPORT void QWindow_title(QWindowH handle, PWideString retval);
C_EXPORT void QWindow_setOpacity(QWindowH handle, qreal level);
C_EXPORT qreal QWindow_opacity(QWindowH handle);
C_EXPORT void QWindow_setMask(QWindowH handle, const QRegionH AnonParam1);
C_EXPORT void QWindow_mask(QWindowH handle, QRegionH retval);
C_EXPORT bool QWindow_isActive(QWindowH handle);
C_EXPORT void QWindow_reportContentOrientationChange(QWindowH handle, Qt::ScreenOrientation orientation);
C_EXPORT Qt::ScreenOrientation QWindow_contentOrientation(QWindowH handle);
C_EXPORT qreal QWindow_devicePixelRatio(QWindowH handle);
C_EXPORT unsigned int QWindow_windowState(QWindowH handle);
C_EXPORT void QWindow_setWindowState(QWindowH handle, unsigned int state);
C_EXPORT void QWindow_setTransientParent(QWindowH handle, QWindowH parent);
C_EXPORT QWindowH QWindow_transientParent(QWindowH handle);
C_EXPORT bool QWindow_isAncestorOf(QWindowH handle, const QWindowH child, QWindow::AncestorMode mode = QWindow::AncestorMode::IncludeTransients);
C_EXPORT bool QWindow_isExposed(QWindowH handle);
C_EXPORT int QWindow_minimumWidth(QWindowH handle);
C_EXPORT int QWindow_minimumHeight(QWindowH handle);
C_EXPORT int QWindow_maximumWidth(QWindowH handle);
C_EXPORT int QWindow_maximumHeight(QWindowH handle);
C_EXPORT void QWindow_minimumSize(QWindowH handle, PSize retval);
C_EXPORT void QWindow_maximumSize(QWindowH handle, PSize retval);
C_EXPORT void QWindow_baseSize(QWindowH handle, PSize retval);
C_EXPORT void QWindow_sizeIncrement(QWindowH handle, PSize retval);
C_EXPORT void QWindow_setMinimumSize(QWindowH handle, const QSizeH AnonParam1);
C_EXPORT void QWindow_setMaximumSize(QWindowH handle, const QSizeH AnonParam1);
C_EXPORT void QWindow_setBaseSize(QWindowH handle, const QSizeH AnonParam1);
C_EXPORT void QWindow_setSizeIncrement(QWindowH handle, const QSizeH AnonParam1);
C_EXPORT void QWindow_setGeometry(QWindowH handle, int x, int y, int w, int h);
C_EXPORT void QWindow_setGeometry2(QWindowH handle, PRect AnonParam1);
C_EXPORT void QWindow_geometry(QWindowH handle, PRect retval);
C_EXPORT void QWindow_frameMargins(QWindowH handle, QMarginsH retval);
C_EXPORT void QWindow_frameGeometry(QWindowH handle, PRect retval);
C_EXPORT void QWindow_framePosition(QWindowH handle, PQtPoint retval);
C_EXPORT void QWindow_setFramePosition(QWindowH handle, const QPointH AnonParam1);
C_EXPORT int QWindow_width(QWindowH handle);
C_EXPORT int QWindow_height(QWindowH handle);
C_EXPORT int QWindow_x(QWindowH handle);
C_EXPORT int QWindow_y(QWindowH handle);
C_EXPORT void QWindow_size(QWindowH handle, PSize retval);
C_EXPORT void QWindow_position(QWindowH handle, PQtPoint retval);
C_EXPORT void QWindow_setPosition(QWindowH handle, const QPointH AnonParam1);
C_EXPORT void QWindow_setPosition2(QWindowH handle, int posx, int posy);
C_EXPORT void QWindow_resize(QWindowH handle, const QSizeH AnonParam1);
C_EXPORT void QWindow_resize2(QWindowH handle, int w, int h);
C_EXPORT void QWindow_setFilePath(QWindowH handle, PWideString AnonParam1);
C_EXPORT void QWindow_filePath(QWindowH handle, PWideString retval);
C_EXPORT void QWindow_setIcon(QWindowH handle, const QIconH icon);
C_EXPORT void QWindow_icon(QWindowH handle, QIconH retval);
C_EXPORT QScreenH QWindow_screen(QWindowH handle);
C_EXPORT void QWindow_setScreen(QWindowH handle, QScreenH screen);
C_EXPORT bool QWindow_setKeyboardGrabEnabled(QWindowH handle, bool grab);
C_EXPORT bool QWindow_setMouseGrabEnabled(QWindowH handle, bool grab);
C_EXPORT void QWindow_mapToGlobal(QWindowH handle, PQtPoint retval, const QPointH AnonParam1);
C_EXPORT void QWindow_mapFromGlobal(QWindowH handle, PQtPoint retval, const QPointH AnonParam1);
C_EXPORT void QWindow_cursor(QWindowH handle, QCursorH retval);
C_EXPORT void QWindow_setCursor(QWindowH handle, const QCursorH AnonParam1);
C_EXPORT void QWindow_unsetCursor(QWindowH handle);
C_EXPORT QObjectH QWindow_focusObject(QWindowH handle);
C_EXPORT QWindowH QWindow_fromWinID(unsigned int id);
C_EXPORT void QWindow_requestActivate(QWindowH handle);
C_EXPORT void QWindow_setVisible(QWindowH handle, bool visible);
C_EXPORT void QWindow_show(QWindowH handle);
C_EXPORT void QWindow_hide(QWindowH handle);
C_EXPORT void QWindow_showMinimized(QWindowH handle);
C_EXPORT void QWindow_showMaximized(QWindowH handle);
C_EXPORT void QWindow_showFullScreen(QWindowH handle);
C_EXPORT void QWindow_showNormal(QWindowH handle);
C_EXPORT bool QWindow_close(QWindowH handle);
C_EXPORT void QWindow_raise(QWindowH handle);
C_EXPORT void QWindow_lower(QWindowH handle);
C_EXPORT void QWindow_setTitle(QWindowH handle, PWideString AnonParam1);
C_EXPORT void QWindow_setX(QWindowH handle, int argx);
C_EXPORT void QWindow_setY(QWindowH handle, int argy);
C_EXPORT void QWindow_setWidth(QWindowH handle, int argw);
C_EXPORT void QWindow_setHeight(QWindowH handle, int argh);
C_EXPORT void QWindow_setMinimumWidth(QWindowH handle, int w);
C_EXPORT void QWindow_setMinimumHeight(QWindowH handle, int h);
C_EXPORT void QWindow_setMaximumWidth(QWindowH handle, int w);
C_EXPORT void QWindow_setMaximumHeight(QWindowH handle, int h);
C_EXPORT void QWindow_alert(QWindowH handle, int msec);
C_EXPORT void QWindow_requestUpdate(QWindowH handle);
#endif

341
lcl/interfaces/qt5/cbindings/src/qwindow_hook.h Normal file
View File

@ -0,0 +1,341 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QWINDOW_HOOK_H
#define QWINDOW_HOOK_H
#include <qwindow.h>
#include "qobject_hook.h"
class QWindow_hook : public QObject_hook {
Q_OBJECT
public:
QWindow_hook(QObject *handle) : QObject_hook(handle) {
screenChanged_event.func = NULL;;
modalityChanged_event.func = NULL;;
windowStateChanged_event.func = NULL;;
windowTitleChanged_event.func = NULL;;
xChanged_event.func = NULL;;
yChanged_event.func = NULL;;
widthChanged_event.func = NULL;;
heightChanged_event.func = NULL;;
minimumWidthChanged_event.func = NULL;;
minimumHeightChanged_event.func = NULL;;
maximumWidthChanged_event.func = NULL;;
maximumHeightChanged_event.func = NULL;;
visibleChanged_event.func = NULL;;
visibilityChanged_event.func = NULL;;
activeChanged_event.func = NULL;;
contentOrientationChanged_event.func = NULL;;
focusObjectChanged_event.func = NULL;;
opacityChanged_event.func = NULL;;
}
void hook_screenChanged(QHook &hook) {
if ( !screenChanged_event.func )
connect(handle, SIGNAL(screenChanged(QScreen*)), this, SLOT(screenChanged_hook(QScreen*)));
screenChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(screenChanged(QScreen*)), this, SLOT(screenChanged_hook(QScreen*)));
}
void hook_modalityChanged(QHook &hook) {
if ( !modalityChanged_event.func )
connect(handle, SIGNAL(modalityChanged(Qt::WindowModality)), this, SLOT(modalityChanged_hook(Qt::WindowModality)));
modalityChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(modalityChanged(Qt::WindowModality)), this, SLOT(modalityChanged_hook(Qt::WindowModality)));
}
void hook_windowStateChanged(QHook &hook) {
if ( !windowStateChanged_event.func )
connect(handle, SIGNAL(windowStateChanged(Qt::WindowState)), this, SLOT(windowStateChanged_hook(Qt::WindowState)));
windowStateChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(windowStateChanged(Qt::WindowState)), this, SLOT(windowStateChanged_hook(Qt::WindowState)));
}
void hook_windowTitleChanged(QHook &hook) {
if ( !windowTitleChanged_event.func )
connect(handle, SIGNAL(windowTitleChanged(const QString&)), this, SLOT(windowTitleChanged_hook(const QString&)));
windowTitleChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(windowTitleChanged(const QString&)), this, SLOT(windowTitleChanged_hook(const QString&)));
}
void hook_xChanged(QHook &hook) {
if ( !xChanged_event.func )
connect(handle, SIGNAL(xChanged(int)), this, SLOT(xChanged_hook(int)));
xChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(xChanged(int)), this, SLOT(xChanged_hook(int)));
}
void hook_yChanged(QHook &hook) {
if ( !yChanged_event.func )
connect(handle, SIGNAL(yChanged(int)), this, SLOT(yChanged_hook(int)));
yChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(yChanged(int)), this, SLOT(yChanged_hook(int)));
}
void hook_widthChanged(QHook &hook) {
if ( !widthChanged_event.func )
connect(handle, SIGNAL(widthChanged(int)), this, SLOT(widthChanged_hook(int)));
widthChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(widthChanged(int)), this, SLOT(widthChanged_hook(int)));
}
void hook_heightChanged(QHook &hook) {
if ( !heightChanged_event.func )
connect(handle, SIGNAL(heightChanged(int)), this, SLOT(heightChanged_hook(int)));
heightChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(heightChanged(int)), this, SLOT(heightChanged_hook(int)));
}
void hook_minimumWidthChanged(QHook &hook) {
if ( !minimumWidthChanged_event.func )
connect(handle, SIGNAL(minimumWidthChanged(int)), this, SLOT(minimumWidthChanged_hook(int)));
minimumWidthChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(minimumWidthChanged(int)), this, SLOT(minimumWidthChanged_hook(int)));
}
void hook_minimumHeightChanged(QHook &hook) {
if ( !minimumHeightChanged_event.func )
connect(handle, SIGNAL(minimumHeightChanged(int)), this, SLOT(minimumHeightChanged_hook(int)));
minimumHeightChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(minimumHeightChanged(int)), this, SLOT(minimumHeightChanged_hook(int)));
}
void hook_maximumWidthChanged(QHook &hook) {
if ( !maximumWidthChanged_event.func )
connect(handle, SIGNAL(maximumWidthChanged(int)), this, SLOT(maximumWidthChanged_hook(int)));
maximumWidthChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(maximumWidthChanged(int)), this, SLOT(maximumWidthChanged_hook(int)));
}
void hook_maximumHeightChanged(QHook &hook) {
if ( !maximumHeightChanged_event.func )
connect(handle, SIGNAL(maximumHeightChanged(int)), this, SLOT(maximumHeightChanged_hook(int)));
maximumHeightChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(maximumHeightChanged(int)), this, SLOT(maximumHeightChanged_hook(int)));
}
void hook_visibleChanged(QHook &hook) {
if ( !visibleChanged_event.func )
connect(handle, SIGNAL(visibleChanged(bool)), this, SLOT(visibleChanged_hook(bool)));
visibleChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(visibleChanged(bool)), this, SLOT(visibleChanged_hook(bool)));
}
void hook_visibilityChanged(QHook &hook) {
if ( !visibilityChanged_event.func )
connect(handle, SIGNAL(visibilityChanged(QWindow::Visibility)), this, SLOT(visibilityChanged_hook(QWindow::Visibility)));
visibilityChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(visibilityChanged(QWindow::Visibility)), this, SLOT(visibilityChanged_hook(QWindow::Visibility)));
}
void hook_activeChanged(QHook &hook) {
if ( !activeChanged_event.func )
connect(handle, SIGNAL(activeChanged()), this, SLOT(activeChanged_hook()));
activeChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(activeChanged()), this, SLOT(activeChanged_hook()));
}
void hook_contentOrientationChanged(QHook &hook) {
if ( !contentOrientationChanged_event.func )
connect(handle, SIGNAL(contentOrientationChanged(Qt::ScreenOrientation)), this, SLOT(contentOrientationChanged_hook(Qt::ScreenOrientation)));
contentOrientationChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(contentOrientationChanged(Qt::ScreenOrientation)), this, SLOT(contentOrientationChanged_hook(Qt::ScreenOrientation)));
}
void hook_focusObjectChanged(QHook &hook) {
if ( !focusObjectChanged_event.func )
connect(handle, SIGNAL(focusObjectChanged(QObject*)), this, SLOT(focusObjectChanged_hook(QObject*)));
focusObjectChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(focusObjectChanged(QObject*)), this, SLOT(focusObjectChanged_hook(QObject*)));
}
void hook_opacityChanged(QHook &hook) {
if ( !opacityChanged_event.func )
connect(handle, SIGNAL(opacityChanged(qreal)), this, SLOT(opacityChanged_hook(qreal)));
opacityChanged_event = hook;
if ( !hook.func )
disconnect(handle, SIGNAL(opacityChanged(qreal)), this, SLOT(opacityChanged_hook(qreal)));
}
private slots:
void screenChanged_hook(QScreen* screen) {
if ( screenChanged_event.func ) {
typedef void (*func_type)(void *data, QScreenH screen);
(*(func_type)screenChanged_event.func)(screenChanged_event.data, (QScreenH)screen);
}
}
void modalityChanged_hook(Qt::WindowModality modality) {
if ( modalityChanged_event.func ) {
typedef void (*func_type)(void *data, Qt::WindowModality modality);
(*(func_type)modalityChanged_event.func)(modalityChanged_event.data, modality);
}
}
void windowStateChanged_hook(Qt::WindowState windowState) {
if ( windowStateChanged_event.func ) {
typedef void (*func_type)(void *data, Qt::WindowState windowState);
(*(func_type)windowStateChanged_event.func)(windowStateChanged_event.data, windowState);
}
}
void windowTitleChanged_hook(const QString& title) {
if ( windowTitleChanged_event.func ) {
typedef void (*func_type)(void *data, PWideString title);
PWideString t_title;
initializePWideString(t_title);
copyQStringToPWideString(title, t_title);
(*(func_type)windowTitleChanged_event.func)(windowTitleChanged_event.data, t_title);
finalizePWideString(t_title);
}
}
void xChanged_hook(int arg) {
if ( xChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)xChanged_event.func)(xChanged_event.data, arg);
}
}
void yChanged_hook(int arg) {
if ( yChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)yChanged_event.func)(yChanged_event.data, arg);
}
}
void widthChanged_hook(int arg) {
if ( widthChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)widthChanged_event.func)(widthChanged_event.data, arg);
}
}
void heightChanged_hook(int arg) {
if ( heightChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)heightChanged_event.func)(heightChanged_event.data, arg);
}
}
void minimumWidthChanged_hook(int arg) {
if ( minimumWidthChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)minimumWidthChanged_event.func)(minimumWidthChanged_event.data, arg);
}
}
void minimumHeightChanged_hook(int arg) {
if ( minimumHeightChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)minimumHeightChanged_event.func)(minimumHeightChanged_event.data, arg);
}
}
void maximumWidthChanged_hook(int arg) {
if ( maximumWidthChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)maximumWidthChanged_event.func)(maximumWidthChanged_event.data, arg);
}
}
void maximumHeightChanged_hook(int arg) {
if ( maximumHeightChanged_event.func ) {
typedef void (*func_type)(void *data, int arg);
(*(func_type)maximumHeightChanged_event.func)(maximumHeightChanged_event.data, arg);
}
}
void visibleChanged_hook(bool arg) {
if ( visibleChanged_event.func ) {
typedef void (*func_type)(void *data, bool arg);
(*(func_type)visibleChanged_event.func)(visibleChanged_event.data, arg);
}
}
void visibilityChanged_hook(QWindow::Visibility visibility) {
if ( visibilityChanged_event.func ) {
typedef void (*func_type)(void *data, QWindow::Visibility visibility);
(*(func_type)visibilityChanged_event.func)(visibilityChanged_event.data, visibility);
}
}
void activeChanged_hook() {
if ( activeChanged_event.func ) {
typedef void (*func_type)(void *data);
(*(func_type)activeChanged_event.func)(activeChanged_event.data);
}
}
void contentOrientationChanged_hook(Qt::ScreenOrientation orientation) {
if ( contentOrientationChanged_event.func ) {
typedef void (*func_type)(void *data, Qt::ScreenOrientation orientation);
(*(func_type)contentOrientationChanged_event.func)(contentOrientationChanged_event.data, orientation);
}
}
void focusObjectChanged_hook(QObject* object) {
if ( focusObjectChanged_event.func ) {
typedef void (*func_type)(void *data, QObjectH object);
(*(func_type)focusObjectChanged_event.func)(focusObjectChanged_event.data, (QObjectH)object);
}
}
void opacityChanged_hook(qreal opacity) {
if ( opacityChanged_event.func ) {
typedef void (*func_type)(void *data, qreal opacity);
(*(func_type)opacityChanged_event.func)(opacityChanged_event.data, opacity);
}
}
private:
QHook screenChanged_event;
QHook modalityChanged_event;
QHook windowStateChanged_event;
QHook windowTitleChanged_event;
QHook xChanged_event;
QHook yChanged_event;
QHook widthChanged_event;
QHook heightChanged_event;
QHook minimumWidthChanged_event;
QHook minimumHeightChanged_event;
QHook maximumWidthChanged_event;
QHook maximumHeightChanged_event;
QHook visibleChanged_event;
QHook visibilityChanged_event;
QHook activeChanged_event;
QHook contentOrientationChanged_event;
QHook focusObjectChanged_event;
QHook opacityChanged_event;
};
#endif

112
lcl/interfaces/qt5/cbindings/src/qwindow_hook_c.cpp Normal file
View File

@ -0,0 +1,112 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#include "qwindow_hook_c.h"
QWindow_hookH QWindow_hook_Create(QObjectH handle)
{
return (QWindow_hookH) new QWindow_hook((QObject*)handle);
}
void QWindow_hook_Destroy(QWindow_hookH handle)
{
delete (QWindow_hook *)handle;
}
void QWindow_hook_hook_screenChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_screenChanged(hook);
}
void QWindow_hook_hook_modalityChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_modalityChanged(hook);
}
void QWindow_hook_hook_windowStateChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_windowStateChanged(hook);
}
void QWindow_hook_hook_windowTitleChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_windowTitleChanged(hook);
}
void QWindow_hook_hook_xChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_xChanged(hook);
}
void QWindow_hook_hook_yChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_yChanged(hook);
}
void QWindow_hook_hook_widthChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_widthChanged(hook);
}
void QWindow_hook_hook_heightChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_heightChanged(hook);
}
void QWindow_hook_hook_minimumWidthChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_minimumWidthChanged(hook);
}
void QWindow_hook_hook_minimumHeightChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_minimumHeightChanged(hook);
}
void QWindow_hook_hook_maximumWidthChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_maximumWidthChanged(hook);
}
void QWindow_hook_hook_maximumHeightChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_maximumHeightChanged(hook);
}
void QWindow_hook_hook_visibleChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_visibleChanged(hook);
}
void QWindow_hook_hook_visibilityChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_visibilityChanged(hook);
}
void QWindow_hook_hook_activeChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_activeChanged(hook);
}
void QWindow_hook_hook_contentOrientationChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_contentOrientationChanged(hook);
}
void QWindow_hook_hook_focusObjectChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_focusObjectChanged(hook);
}
void QWindow_hook_hook_opacityChanged(QWindow_hookH handle, QHookH hook)
{
((QWindow_hook *)handle)->hook_opacityChanged(hook);
}

38
lcl/interfaces/qt5/cbindings/src/qwindow_hook_c.h Normal file
View File

@ -0,0 +1,38 @@
//******************************************************************************
// Copyright (c) 2017 by Željan Rikalo
//
// See the included file COPYING.TXT for details about the copyright.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//******************************************************************************
#ifndef QWINDOW_HOOK_C_H
#define QWINDOW_HOOK_C_H
#include "qwindow_hook.h"
C_EXPORT QWindow_hookH QWindow_hook_Create(QObjectH handle);
C_EXPORT void QWindow_hook_Destroy(QWindow_hookH handle);
C_EXPORT void QWindow_hook_hook_screenChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_modalityChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_windowStateChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_windowTitleChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_xChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_yChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_widthChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_heightChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_minimumWidthChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_minimumHeightChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_maximumWidthChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_maximumHeightChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_visibleChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_visibilityChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_activeChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_contentOrientationChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_focusObjectChanged(QWindow_hookH handle, QHookH hook);
C_EXPORT void QWindow_hook_hook_opacityChanged(QWindow_hookH handle, QHookH hook);
#endif