lib/cutego
1
0
Fork 0
mirror of https://github.com/bluszcz/cutego.git synced 2024-09-28 13:15:17 +03:00
Code Issues Projects Releases Packages Wiki Activity

fixes for various minor issues

Browse source
This commit is contained in:
therecipe 2018-10-14 18:50:54 +02:00
parent e06f9cf01c
commit c1f31803cb
25 changed files with 510 additions and 2181 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

690
datavisualization/datavisualization.cpp
View file

@ -3150,656 +3150,6 @@ float QAbstract3DAxis_Min(void* ptr)
return static_cast<QAbstract3DAxis*>(ptr)->min();
}
class MyQAbstract3DGraph: public QAbstract3DGraph
{
public:
void Signal_ActiveInputHandlerChanged(QAbstract3DInputHandler * inputHandler) { callbackQAbstract3DGraph_ActiveInputHandlerChanged(this, inputHandler); };
void Signal_ActiveThemeChanged(Q3DTheme * theme) { callbackQAbstract3DGraph_ActiveThemeChanged(this, theme); };
void Signal_AspectRatioChanged(qreal ratio) { callbackQAbstract3DGraph_AspectRatioChanged(this, ratio); };
void Signal_CurrentFpsChanged(qreal fps) { callbackQAbstract3DGraph_CurrentFpsChanged(this, fps); };
void Signal_HorizontalAspectRatioChanged(qreal ratio) { callbackQAbstract3DGraph_HorizontalAspectRatioChanged(this, ratio); };
void Signal_LocaleChanged(const QLocale & locale) { callbackQAbstract3DGraph_LocaleChanged(this, const_cast<QLocale*>(&locale)); };
void Signal_MarginChanged(qreal margin) { callbackQAbstract3DGraph_MarginChanged(this, margin); };
void Signal_MeasureFpsChanged(bool enabled) { callbackQAbstract3DGraph_MeasureFpsChanged(this, enabled); };
void Signal_OptimizationHintsChanged(QAbstract3DGraph::OptimizationHints hints) { callbackQAbstract3DGraph_OptimizationHintsChanged(this, hints); };
void Signal_OrthoProjectionChanged(bool enabled) { callbackQAbstract3DGraph_OrthoProjectionChanged(this, enabled); };
void Signal_PolarChanged(bool enabled) { callbackQAbstract3DGraph_PolarChanged(this, enabled); };
void Signal_QueriedGraphPositionChanged(const QVector3D & data) { callbackQAbstract3DGraph_QueriedGraphPositionChanged(this, const_cast<QVector3D*>(&data)); };
void Signal_RadialLabelOffsetChanged(float offset) { callbackQAbstract3DGraph_RadialLabelOffsetChanged(this, offset); };
void Signal_ReflectionChanged(bool enabled) { callbackQAbstract3DGraph_ReflectionChanged(this, enabled); };
void Signal_ReflectivityChanged(qreal reflectivity) { callbackQAbstract3DGraph_ReflectivityChanged(this, reflectivity); };
void Signal_SelectedElementChanged(QAbstract3DGraph::ElementType ty) { callbackQAbstract3DGraph_SelectedElementChanged(this, ty); };
void Signal_SelectionModeChanged(QAbstract3DGraph::SelectionFlags mode) { callbackQAbstract3DGraph_SelectionModeChanged(this, mode); };
void Signal_ShadowQualityChanged(QAbstract3DGraph::ShadowQuality quality) { callbackQAbstract3DGraph_ShadowQualityChanged(this, quality); };
~MyQAbstract3DGraph() { callbackQAbstract3DGraph_DestroyQAbstract3DGraph(this); };
bool shadowsSupported() const { return callbackQAbstract3DGraph_ShadowsSupported(const_cast<void*>(static_cast<const void*>(this))) != 0; };
const QMetaObject * metaObject() const { return static_cast<QMetaObject*>(callbackQAbstract3DGraph_MetaObject(const_cast<void*>(static_cast<const void*>(this)))); };
};
void* QAbstract3DGraph_RenderToImage(void* ptr, int msaaSamples, void* imageSize)
{
return new QImage(static_cast<QAbstract3DGraph*>(ptr)->renderToImage(msaaSamples, *static_cast<QSize*>(imageSize)));
}
struct QtDataVisualization_PackedString QAbstract3DGraph_QAbstract3DGraph_Tr(char* s, char* c, int n)
{
return ({ QByteArray t947268 = QAbstract3DGraph::tr(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtDataVisualization_PackedString { const_cast<char*>(t947268.prepend("WHITESPACE").constData()+10), t947268.size()-10 }; });
}
struct QtDataVisualization_PackedString QAbstract3DGraph_QAbstract3DGraph_TrUtf8(char* s, char* c, int n)
{
return ({ QByteArray t545ea9 = QAbstract3DGraph::trUtf8(const_cast<const char*>(s), const_cast<const char*>(c), n).toUtf8(); QtDataVisualization_PackedString { const_cast<char*>(t545ea9.prepend("WHITESPACE").constData()+10), t545ea9.size()-10 }; });
}
int QAbstract3DGraph_AddCustomItem(void* ptr, void* item)
{
return static_cast<QAbstract3DGraph*>(ptr)->addCustomItem(static_cast<QCustom3DItem*>(item));
}
void QAbstract3DGraph_ConnectActiveInputHandlerChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DInputHandler *)>(&QAbstract3DGraph::activeInputHandlerChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DInputHandler *)>(&MyQAbstract3DGraph::Signal_ActiveInputHandlerChanged));
}
void QAbstract3DGraph_DisconnectActiveInputHandlerChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DInputHandler *)>(&QAbstract3DGraph::activeInputHandlerChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DInputHandler *)>(&MyQAbstract3DGraph::Signal_ActiveInputHandlerChanged));
}
void QAbstract3DGraph_ActiveInputHandlerChanged(void* ptr, void* inputHandler)
{
static_cast<QAbstract3DGraph*>(ptr)->activeInputHandlerChanged(static_cast<QAbstract3DInputHandler*>(inputHandler));
}
void QAbstract3DGraph_ConnectActiveThemeChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(Q3DTheme *)>(&QAbstract3DGraph::activeThemeChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(Q3DTheme *)>(&MyQAbstract3DGraph::Signal_ActiveThemeChanged));
}
void QAbstract3DGraph_DisconnectActiveThemeChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(Q3DTheme *)>(&QAbstract3DGraph::activeThemeChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(Q3DTheme *)>(&MyQAbstract3DGraph::Signal_ActiveThemeChanged));
}
void QAbstract3DGraph_ActiveThemeChanged(void* ptr, void* theme)
{
static_cast<QAbstract3DGraph*>(ptr)->activeThemeChanged(static_cast<Q3DTheme*>(theme));
}
void QAbstract3DGraph_AddInputHandler(void* ptr, void* inputHandler)
{
static_cast<QAbstract3DGraph*>(ptr)->addInputHandler(static_cast<QAbstract3DInputHandler*>(inputHandler));
}
void QAbstract3DGraph_AddTheme(void* ptr, void* theme)
{
static_cast<QAbstract3DGraph*>(ptr)->addTheme(static_cast<Q3DTheme*>(theme));
}
void QAbstract3DGraph_ConnectAspectRatioChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::aspectRatioChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_AspectRatioChanged));
}
void QAbstract3DGraph_DisconnectAspectRatioChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::aspectRatioChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_AspectRatioChanged));
}
void QAbstract3DGraph_AspectRatioChanged(void* ptr, double ratio)
{
static_cast<QAbstract3DGraph*>(ptr)->aspectRatioChanged(ratio);
}
void QAbstract3DGraph_ClearSelection(void* ptr)
{
static_cast<QAbstract3DGraph*>(ptr)->clearSelection();
}
void QAbstract3DGraph_ConnectCurrentFpsChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::currentFpsChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_CurrentFpsChanged));
}
void QAbstract3DGraph_DisconnectCurrentFpsChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::currentFpsChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_CurrentFpsChanged));
}
void QAbstract3DGraph_CurrentFpsChanged(void* ptr, double fps)
{
static_cast<QAbstract3DGraph*>(ptr)->currentFpsChanged(fps);
}
void QAbstract3DGraph_ConnectHorizontalAspectRatioChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::horizontalAspectRatioChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_HorizontalAspectRatioChanged));
}
void QAbstract3DGraph_DisconnectHorizontalAspectRatioChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::horizontalAspectRatioChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_HorizontalAspectRatioChanged));
}
void QAbstract3DGraph_HorizontalAspectRatioChanged(void* ptr, double ratio)
{
static_cast<QAbstract3DGraph*>(ptr)->horizontalAspectRatioChanged(ratio);
}
void QAbstract3DGraph_ConnectLocaleChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(const QLocale &)>(&QAbstract3DGraph::localeChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(const QLocale &)>(&MyQAbstract3DGraph::Signal_LocaleChanged));
}
void QAbstract3DGraph_DisconnectLocaleChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(const QLocale &)>(&QAbstract3DGraph::localeChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(const QLocale &)>(&MyQAbstract3DGraph::Signal_LocaleChanged));
}
void QAbstract3DGraph_LocaleChanged(void* ptr, void* locale)
{
static_cast<QAbstract3DGraph*>(ptr)->localeChanged(*static_cast<QLocale*>(locale));
}
void QAbstract3DGraph_ConnectMarginChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::marginChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_MarginChanged));
}
void QAbstract3DGraph_DisconnectMarginChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::marginChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_MarginChanged));
}
void QAbstract3DGraph_MarginChanged(void* ptr, double margin)
{
static_cast<QAbstract3DGraph*>(ptr)->marginChanged(margin);
}
void QAbstract3DGraph_ConnectMeasureFpsChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::measureFpsChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_MeasureFpsChanged));
}
void QAbstract3DGraph_DisconnectMeasureFpsChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::measureFpsChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_MeasureFpsChanged));
}
void QAbstract3DGraph_MeasureFpsChanged(void* ptr, char enabled)
{
static_cast<QAbstract3DGraph*>(ptr)->measureFpsChanged(enabled != 0);
}
void QAbstract3DGraph_ConnectOptimizationHintsChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::OptimizationHints)>(&QAbstract3DGraph::optimizationHintsChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::OptimizationHints)>(&MyQAbstract3DGraph::Signal_OptimizationHintsChanged));
}
void QAbstract3DGraph_DisconnectOptimizationHintsChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::OptimizationHints)>(&QAbstract3DGraph::optimizationHintsChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::OptimizationHints)>(&MyQAbstract3DGraph::Signal_OptimizationHintsChanged));
}
void QAbstract3DGraph_OptimizationHintsChanged(void* ptr, long long hints)
{
static_cast<QAbstract3DGraph*>(ptr)->optimizationHintsChanged(static_cast<QAbstract3DGraph::OptimizationHint>(hints));
}
void QAbstract3DGraph_ConnectOrthoProjectionChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::orthoProjectionChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_OrthoProjectionChanged));
}
void QAbstract3DGraph_DisconnectOrthoProjectionChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::orthoProjectionChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_OrthoProjectionChanged));
}
void QAbstract3DGraph_OrthoProjectionChanged(void* ptr, char enabled)
{
static_cast<QAbstract3DGraph*>(ptr)->orthoProjectionChanged(enabled != 0);
}
void QAbstract3DGraph_ConnectPolarChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::polarChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_PolarChanged));
}
void QAbstract3DGraph_DisconnectPolarChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::polarChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_PolarChanged));
}
void QAbstract3DGraph_PolarChanged(void* ptr, char enabled)
{
static_cast<QAbstract3DGraph*>(ptr)->polarChanged(enabled != 0);
}
void QAbstract3DGraph_ConnectQueriedGraphPositionChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(const QVector3D &)>(&QAbstract3DGraph::queriedGraphPositionChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(const QVector3D &)>(&MyQAbstract3DGraph::Signal_QueriedGraphPositionChanged));
}
void QAbstract3DGraph_DisconnectQueriedGraphPositionChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(const QVector3D &)>(&QAbstract3DGraph::queriedGraphPositionChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(const QVector3D &)>(&MyQAbstract3DGraph::Signal_QueriedGraphPositionChanged));
}
void QAbstract3DGraph_QueriedGraphPositionChanged(void* ptr, void* data)
{
static_cast<QAbstract3DGraph*>(ptr)->queriedGraphPositionChanged(*static_cast<QVector3D*>(data));
}
void QAbstract3DGraph_ConnectRadialLabelOffsetChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(float)>(&QAbstract3DGraph::radialLabelOffsetChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(float)>(&MyQAbstract3DGraph::Signal_RadialLabelOffsetChanged));
}
void QAbstract3DGraph_DisconnectRadialLabelOffsetChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(float)>(&QAbstract3DGraph::radialLabelOffsetChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(float)>(&MyQAbstract3DGraph::Signal_RadialLabelOffsetChanged));
}
void QAbstract3DGraph_RadialLabelOffsetChanged(void* ptr, float offset)
{
static_cast<QAbstract3DGraph*>(ptr)->radialLabelOffsetChanged(offset);
}
void QAbstract3DGraph_ConnectReflectionChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::reflectionChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_ReflectionChanged));
}
void QAbstract3DGraph_DisconnectReflectionChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(bool)>(&QAbstract3DGraph::reflectionChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(bool)>(&MyQAbstract3DGraph::Signal_ReflectionChanged));
}
void QAbstract3DGraph_ReflectionChanged(void* ptr, char enabled)
{
static_cast<QAbstract3DGraph*>(ptr)->reflectionChanged(enabled != 0);
}
void QAbstract3DGraph_ConnectReflectivityChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::reflectivityChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_ReflectivityChanged));
}
void QAbstract3DGraph_DisconnectReflectivityChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(qreal)>(&QAbstract3DGraph::reflectivityChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(qreal)>(&MyQAbstract3DGraph::Signal_ReflectivityChanged));
}
void QAbstract3DGraph_ReflectivityChanged(void* ptr, double reflectivity)
{
static_cast<QAbstract3DGraph*>(ptr)->reflectivityChanged(reflectivity);
}
void QAbstract3DGraph_ReleaseCustomItem(void* ptr, void* item)
{
static_cast<QAbstract3DGraph*>(ptr)->releaseCustomItem(static_cast<QCustom3DItem*>(item));
}
void QAbstract3DGraph_ReleaseInputHandler(void* ptr, void* inputHandler)
{
static_cast<QAbstract3DGraph*>(ptr)->releaseInputHandler(static_cast<QAbstract3DInputHandler*>(inputHandler));
}
void QAbstract3DGraph_ReleaseTheme(void* ptr, void* theme)
{
static_cast<QAbstract3DGraph*>(ptr)->releaseTheme(static_cast<Q3DTheme*>(theme));
}
void QAbstract3DGraph_RemoveCustomItem(void* ptr, void* item)
{
static_cast<QAbstract3DGraph*>(ptr)->removeCustomItem(static_cast<QCustom3DItem*>(item));
}
void QAbstract3DGraph_RemoveCustomItemAt(void* ptr, void* position)
{
static_cast<QAbstract3DGraph*>(ptr)->removeCustomItemAt(*static_cast<QVector3D*>(position));
}
void QAbstract3DGraph_RemoveCustomItems(void* ptr)
{
static_cast<QAbstract3DGraph*>(ptr)->removeCustomItems();
}
void QAbstract3DGraph_ConnectSelectedElementChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::ElementType)>(&QAbstract3DGraph::selectedElementChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::ElementType)>(&MyQAbstract3DGraph::Signal_SelectedElementChanged));
}
void QAbstract3DGraph_DisconnectSelectedElementChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::ElementType)>(&QAbstract3DGraph::selectedElementChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::ElementType)>(&MyQAbstract3DGraph::Signal_SelectedElementChanged));
}
void QAbstract3DGraph_SelectedElementChanged(void* ptr, long long ty)
{
static_cast<QAbstract3DGraph*>(ptr)->selectedElementChanged(static_cast<QAbstract3DGraph::ElementType>(ty));
}
void QAbstract3DGraph_ConnectSelectionModeChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::SelectionFlags)>(&QAbstract3DGraph::selectionModeChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::SelectionFlags)>(&MyQAbstract3DGraph::Signal_SelectionModeChanged));
}
void QAbstract3DGraph_DisconnectSelectionModeChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::SelectionFlags)>(&QAbstract3DGraph::selectionModeChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::SelectionFlags)>(&MyQAbstract3DGraph::Signal_SelectionModeChanged));
}
void QAbstract3DGraph_SelectionModeChanged(void* ptr, long long mode)
{
static_cast<QAbstract3DGraph*>(ptr)->selectionModeChanged(static_cast<QAbstract3DGraph::SelectionFlag>(mode));
}
void QAbstract3DGraph_SetActiveInputHandler(void* ptr, void* inputHandler)
{
static_cast<QAbstract3DGraph*>(ptr)->setActiveInputHandler(static_cast<QAbstract3DInputHandler*>(inputHandler));
}
void QAbstract3DGraph_SetActiveTheme(void* ptr, void* theme)
{
static_cast<QAbstract3DGraph*>(ptr)->setActiveTheme(static_cast<Q3DTheme*>(theme));
}
void QAbstract3DGraph_SetAspectRatio(void* ptr, double ratio)
{
static_cast<QAbstract3DGraph*>(ptr)->setAspectRatio(ratio);
}
void QAbstract3DGraph_SetHorizontalAspectRatio(void* ptr, double ratio)
{
static_cast<QAbstract3DGraph*>(ptr)->setHorizontalAspectRatio(ratio);
}
void QAbstract3DGraph_SetLocale(void* ptr, void* locale)
{
static_cast<QAbstract3DGraph*>(ptr)->setLocale(*static_cast<QLocale*>(locale));
}
void QAbstract3DGraph_SetMargin(void* ptr, double margin)
{
static_cast<QAbstract3DGraph*>(ptr)->setMargin(margin);
}
void QAbstract3DGraph_SetMeasureFps(void* ptr, char enable)
{
static_cast<QAbstract3DGraph*>(ptr)->setMeasureFps(enable != 0);
}
void QAbstract3DGraph_SetOptimizationHints(void* ptr, long long hints)
{
static_cast<QAbstract3DGraph*>(ptr)->setOptimizationHints(static_cast<QAbstract3DGraph::OptimizationHint>(hints));
}
void QAbstract3DGraph_SetOrthoProjection(void* ptr, char enable)
{
static_cast<QAbstract3DGraph*>(ptr)->setOrthoProjection(enable != 0);
}
void QAbstract3DGraph_SetPolar(void* ptr, char enable)
{
static_cast<QAbstract3DGraph*>(ptr)->setPolar(enable != 0);
}
void QAbstract3DGraph_SetRadialLabelOffset(void* ptr, float offset)
{
static_cast<QAbstract3DGraph*>(ptr)->setRadialLabelOffset(offset);
}
void QAbstract3DGraph_SetReflection(void* ptr, char enable)
{
static_cast<QAbstract3DGraph*>(ptr)->setReflection(enable != 0);
}
void QAbstract3DGraph_SetReflectivity(void* ptr, double reflectivity)
{
static_cast<QAbstract3DGraph*>(ptr)->setReflectivity(reflectivity);
}
void QAbstract3DGraph_SetSelectionMode(void* ptr, long long mode)
{
static_cast<QAbstract3DGraph*>(ptr)->setSelectionMode(static_cast<QAbstract3DGraph::SelectionFlag>(mode));
}
void QAbstract3DGraph_SetShadowQuality(void* ptr, long long quality)
{
static_cast<QAbstract3DGraph*>(ptr)->setShadowQuality(static_cast<QAbstract3DGraph::ShadowQuality>(quality));
}
void QAbstract3DGraph_ConnectShadowQualityChanged(void* ptr)
{
QObject::connect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::ShadowQuality)>(&QAbstract3DGraph::shadowQualityChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::ShadowQuality)>(&MyQAbstract3DGraph::Signal_ShadowQualityChanged));
}
void QAbstract3DGraph_DisconnectShadowQualityChanged(void* ptr)
{
QObject::disconnect(static_cast<QAbstract3DGraph*>(ptr), static_cast<void (QAbstract3DGraph::*)(QAbstract3DGraph::ShadowQuality)>(&QAbstract3DGraph::shadowQualityChanged), static_cast<MyQAbstract3DGraph*>(ptr), static_cast<void (MyQAbstract3DGraph::*)(QAbstract3DGraph::ShadowQuality)>(&MyQAbstract3DGraph::Signal_ShadowQualityChanged));
}
void QAbstract3DGraph_ShadowQualityChanged(void* ptr, long long quality)
{
static_cast<QAbstract3DGraph*>(ptr)->shadowQualityChanged(static_cast<QAbstract3DGraph::ShadowQuality>(quality));
}
void QAbstract3DGraph_DestroyQAbstract3DGraph(void* ptr)
{
static_cast<QAbstract3DGraph*>(ptr)->~QAbstract3DGraph();
}
void QAbstract3DGraph_DestroyQAbstract3DGraphDefault(void* ptr)
{
Q_UNUSED(ptr);
}
void* QAbstract3DGraph_Scene(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->scene();
}
void* QAbstract3DGraph_ActiveTheme(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->activeTheme();
}
void* QAbstract3DGraph_SelectedAxis(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->selectedAxis();
}
long long QAbstract3DGraph_SelectedElement(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->selectedElement();
}
long long QAbstract3DGraph_OptimizationHints(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->optimizationHints();
}
long long QAbstract3DGraph_SelectionMode(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->selectionMode();
}
long long QAbstract3DGraph_ShadowQuality(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->shadowQuality();
}
void* QAbstract3DGraph_ActiveInputHandler(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->activeInputHandler();
}
void* QAbstract3DGraph_SelectedCustomItem(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->selectedCustomItem();
}
struct QtDataVisualization_PackedList QAbstract3DGraph_Themes(void* ptr)
{
return ({ QList<Q3DTheme *>* tmpValue = new QList<Q3DTheme *>(static_cast<QAbstract3DGraph*>(ptr)->themes()); QtDataVisualization_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtDataVisualization_PackedList QAbstract3DGraph_InputHandlers(void* ptr)
{
return ({ QList<QAbstract3DInputHandler *>* tmpValue = new QList<QAbstract3DInputHandler *>(static_cast<QAbstract3DGraph*>(ptr)->inputHandlers()); QtDataVisualization_PackedList { tmpValue, tmpValue->size() }; });
}
struct QtDataVisualization_PackedList QAbstract3DGraph_CustomItems(void* ptr)
{
return ({ QList<QCustom3DItem *>* tmpValue = new QList<QCustom3DItem *>(static_cast<QAbstract3DGraph*>(ptr)->customItems()); QtDataVisualization_PackedList { tmpValue, tmpValue->size() }; });
}
void* QAbstract3DGraph_Locale(void* ptr)
{
return new QLocale(static_cast<QAbstract3DGraph*>(ptr)->locale());
}
void* QAbstract3DGraph_QueriedGraphPosition(void* ptr)
{
return new QVector3D(static_cast<QAbstract3DGraph*>(ptr)->queriedGraphPosition());
}
char QAbstract3DGraph_HasContext(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->hasContext();
}
char QAbstract3DGraph_IsOrthoProjection(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->isOrthoProjection();
}
char QAbstract3DGraph_IsPolar(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->isPolar();
}
char QAbstract3DGraph_IsReflection(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->isReflection();
}
char QAbstract3DGraph_MeasureFps(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->measureFps();
}
char QAbstract3DGraph_ShadowsSupported(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->shadowsSupported();
}
char QAbstract3DGraph_ShadowsSupportedDefault(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->QAbstract3DGraph::shadowsSupported();
}
void* QAbstract3DGraph_MetaObject(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QAbstract3DGraph*>(ptr)->metaObject());
}
void* QAbstract3DGraph_MetaObjectDefault(void* ptr)
{
return const_cast<QMetaObject*>(static_cast<QAbstract3DGraph*>(ptr)->QAbstract3DGraph::metaObject());
}
float QAbstract3DGraph_RadialLabelOffset(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->radialLabelOffset();
}
int QAbstract3DGraph_SelectedCustomItemIndex(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->selectedCustomItemIndex();
}
int QAbstract3DGraph_SelectedLabelIndex(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->selectedLabelIndex();
}
double QAbstract3DGraph_AspectRatio(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->aspectRatio();
}
double QAbstract3DGraph_CurrentFps(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->currentFps();
}
double QAbstract3DGraph_HorizontalAspectRatio(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->horizontalAspectRatio();
}
double QAbstract3DGraph_Margin(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->margin();
}
double QAbstract3DGraph_Reflectivity(void* ptr)
{
return static_cast<QAbstract3DGraph*>(ptr)->reflectivity();
}
void* QAbstract3DGraph___themes_atList(void* ptr, int i)
{
return ({Q3DTheme * tmp = static_cast<QList<Q3DTheme *>*>(ptr)->at(i); if (i == static_cast<QList<Q3DTheme *>*>(ptr)->size()-1) { static_cast<QList<Q3DTheme *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstract3DGraph___themes_setList(void* ptr, void* i)
{
static_cast<QList<Q3DTheme *>*>(ptr)->append(static_cast<Q3DTheme*>(i));
}
void* QAbstract3DGraph___themes_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<Q3DTheme *>();
}
void* QAbstract3DGraph___inputHandlers_atList(void* ptr, int i)
{
return ({QAbstract3DInputHandler * tmp = static_cast<QList<QAbstract3DInputHandler *>*>(ptr)->at(i); if (i == static_cast<QList<QAbstract3DInputHandler *>*>(ptr)->size()-1) { static_cast<QList<QAbstract3DInputHandler *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstract3DGraph___inputHandlers_setList(void* ptr, void* i)
{
static_cast<QList<QAbstract3DInputHandler *>*>(ptr)->append(static_cast<QAbstract3DInputHandler*>(i));
}
void* QAbstract3DGraph___inputHandlers_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QAbstract3DInputHandler *>();
}
void* QAbstract3DGraph___customItems_atList(void* ptr, int i)
{
return ({QCustom3DItem * tmp = static_cast<QList<QCustom3DItem *>*>(ptr)->at(i); if (i == static_cast<QList<QCustom3DItem *>*>(ptr)->size()-1) { static_cast<QList<QCustom3DItem *>*>(ptr)->~QList(); free(ptr); }; tmp; });
}
void QAbstract3DGraph___customItems_setList(void* ptr, void* i)
{
static_cast<QList<QCustom3DItem *>*>(ptr)->append(static_cast<QCustom3DItem*>(i));
}
void* QAbstract3DGraph___customItems_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QList<QCustom3DItem *>();
}
class MyQAbstract3DInputHandler: public QAbstract3DInputHandler
{
public:
@ -6013,6 +5363,11 @@ void QCustom3DVolume_SetAlphaMultiplier(void* ptr, float mult)
static_cast<QCustom3DVolume*>(ptr)->setAlphaMultiplier(mult);
}
void QCustom3DVolume_SetColorTable(void* ptr, void* colors)
{
static_cast<QCustom3DVolume*>(ptr)->setColorTable(*static_cast<QVector<QRgb>*>(colors));
}
void QCustom3DVolume_SetDrawSliceFrames(void* ptr, char enable)
{
static_cast<QCustom3DVolume*>(ptr)->setDrawSliceFrames(enable != 0);
@ -6324,6 +5679,11 @@ void* QCustom3DVolume_SliceFrameWidths(void* ptr)
return new QVector3D(static_cast<QCustom3DVolume*>(ptr)->sliceFrameWidths());
}
struct QtDataVisualization_PackedList QCustom3DVolume_ColorTable(void* ptr)
{
return ({ QVector<QRgb>* tmpValue = new QVector<QRgb>(static_cast<QCustom3DVolume*>(ptr)->colorTable()); QtDataVisualization_PackedList { tmpValue, tmpValue->size() }; });
}
char QCustom3DVolume_DrawSliceFrames(void* ptr)
{
return static_cast<QCustom3DVolume*>(ptr)->drawSliceFrames();
@ -6389,18 +5749,48 @@ int QCustom3DVolume_TextureWidth(void* ptr)
return static_cast<QCustom3DVolume*>(ptr)->textureWidth();
}
unsigned int QCustom3DVolume___QCustom3DVolume_colorTable_atList2(void* ptr, int i)
{
return ({QRgb tmp = static_cast<QVector<QRgb>*>(ptr)->at(i); if (i == static_cast<QVector<QRgb>*>(ptr)->size()-1) { static_cast<QVector<QRgb>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QCustom3DVolume___QCustom3DVolume_colorTable_setList2(void* ptr, unsigned int i)
{
static_cast<QVector<QRgb>*>(ptr)->append(i);
}
void* QCustom3DVolume___QCustom3DVolume_colorTable_newList2(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRgb>();
}
unsigned int QCustom3DVolume___setColorTable_colors_atList(void* ptr, int i)
{
return ({QRgb tmp = static_cast<QVector<QRgb>*>(ptr)->at(i); if (i == static_cast<QVector<QRgb>*>(ptr)->size()-1) { static_cast<QVector<QRgb>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QCustom3DVolume___setColorTable_colors_setList(void* ptr, unsigned int i)
{
static_cast<QVector<QRgb>*>(ptr)->append(i);
}
void* QCustom3DVolume___setColorTable_colors_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRgb>();
}
unsigned int QCustom3DVolume___colorTable_atList(void* ptr, int i)
{
return ({QRgb tmp = static_cast<QVector<QRgb>*>(ptr)->at(i); if (i == static_cast<QVector<QRgb>*>(ptr)->size()-1) { static_cast<QVector<QRgb>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QCustom3DVolume___colorTable_setList(void* ptr, unsigned int i)
{
static_cast<QVector<QRgb>*>(ptr)->append(i);
}
void* QCustom3DVolume___colorTable_newList(void* ptr)
{
Q_UNUSED(ptr);

1382
datavisualization/datavisualization.go
View file

File diff suppressed because it is too large Load diff

132
datavisualization/datavisualization.h
View file

@ -532,130 +532,6 @@ void* QAbstract3DAxis_MetaObjectDefault(void* ptr);
float QAbstract3DAxis_LabelAutoRotation(void* ptr);
float QAbstract3DAxis_Max(void* ptr);
float QAbstract3DAxis_Min(void* ptr);
void* QAbstract3DGraph_RenderToImage(void* ptr, int msaaSamples, void* imageSize);
struct QtDataVisualization_PackedString QAbstract3DGraph_QAbstract3DGraph_Tr(char* s, char* c, int n);
struct QtDataVisualization_PackedString QAbstract3DGraph_QAbstract3DGraph_TrUtf8(char* s, char* c, int n);
int QAbstract3DGraph_AddCustomItem(void* ptr, void* item);
void QAbstract3DGraph_ConnectActiveInputHandlerChanged(void* ptr);
void QAbstract3DGraph_DisconnectActiveInputHandlerChanged(void* ptr);
void QAbstract3DGraph_ActiveInputHandlerChanged(void* ptr, void* inputHandler);
void QAbstract3DGraph_ConnectActiveThemeChanged(void* ptr);
void QAbstract3DGraph_DisconnectActiveThemeChanged(void* ptr);
void QAbstract3DGraph_ActiveThemeChanged(void* ptr, void* theme);
void QAbstract3DGraph_AddInputHandler(void* ptr, void* inputHandler);
void QAbstract3DGraph_AddTheme(void* ptr, void* theme);
void QAbstract3DGraph_ConnectAspectRatioChanged(void* ptr);
void QAbstract3DGraph_DisconnectAspectRatioChanged(void* ptr);
void QAbstract3DGraph_AspectRatioChanged(void* ptr, double ratio);
void QAbstract3DGraph_ClearSelection(void* ptr);
void QAbstract3DGraph_ConnectCurrentFpsChanged(void* ptr);
void QAbstract3DGraph_DisconnectCurrentFpsChanged(void* ptr);
void QAbstract3DGraph_CurrentFpsChanged(void* ptr, double fps);
void QAbstract3DGraph_ConnectHorizontalAspectRatioChanged(void* ptr);
void QAbstract3DGraph_DisconnectHorizontalAspectRatioChanged(void* ptr);
void QAbstract3DGraph_HorizontalAspectRatioChanged(void* ptr, double ratio);
void QAbstract3DGraph_ConnectLocaleChanged(void* ptr);
void QAbstract3DGraph_DisconnectLocaleChanged(void* ptr);
void QAbstract3DGraph_LocaleChanged(void* ptr, void* locale);
void QAbstract3DGraph_ConnectMarginChanged(void* ptr);
void QAbstract3DGraph_DisconnectMarginChanged(void* ptr);
void QAbstract3DGraph_MarginChanged(void* ptr, double margin);
void QAbstract3DGraph_ConnectMeasureFpsChanged(void* ptr);
void QAbstract3DGraph_DisconnectMeasureFpsChanged(void* ptr);
void QAbstract3DGraph_MeasureFpsChanged(void* ptr, char enabled);
void QAbstract3DGraph_ConnectOptimizationHintsChanged(void* ptr);
void QAbstract3DGraph_DisconnectOptimizationHintsChanged(void* ptr);
void QAbstract3DGraph_OptimizationHintsChanged(void* ptr, long long hints);
void QAbstract3DGraph_ConnectOrthoProjectionChanged(void* ptr);
void QAbstract3DGraph_DisconnectOrthoProjectionChanged(void* ptr);
void QAbstract3DGraph_OrthoProjectionChanged(void* ptr, char enabled);
void QAbstract3DGraph_ConnectPolarChanged(void* ptr);
void QAbstract3DGraph_DisconnectPolarChanged(void* ptr);
void QAbstract3DGraph_PolarChanged(void* ptr, char enabled);
void QAbstract3DGraph_ConnectQueriedGraphPositionChanged(void* ptr);
void QAbstract3DGraph_DisconnectQueriedGraphPositionChanged(void* ptr);
void QAbstract3DGraph_QueriedGraphPositionChanged(void* ptr, void* data);
void QAbstract3DGraph_ConnectRadialLabelOffsetChanged(void* ptr);
void QAbstract3DGraph_DisconnectRadialLabelOffsetChanged(void* ptr);
void QAbstract3DGraph_RadialLabelOffsetChanged(void* ptr, float offset);
void QAbstract3DGraph_ConnectReflectionChanged(void* ptr);
void QAbstract3DGraph_DisconnectReflectionChanged(void* ptr);
void QAbstract3DGraph_ReflectionChanged(void* ptr, char enabled);
void QAbstract3DGraph_ConnectReflectivityChanged(void* ptr);
void QAbstract3DGraph_DisconnectReflectivityChanged(void* ptr);
void QAbstract3DGraph_ReflectivityChanged(void* ptr, double reflectivity);
void QAbstract3DGraph_ReleaseCustomItem(void* ptr, void* item);
void QAbstract3DGraph_ReleaseInputHandler(void* ptr, void* inputHandler);
void QAbstract3DGraph_ReleaseTheme(void* ptr, void* theme);
void QAbstract3DGraph_RemoveCustomItem(void* ptr, void* item);
void QAbstract3DGraph_RemoveCustomItemAt(void* ptr, void* position);
void QAbstract3DGraph_RemoveCustomItems(void* ptr);
void QAbstract3DGraph_ConnectSelectedElementChanged(void* ptr);
void QAbstract3DGraph_DisconnectSelectedElementChanged(void* ptr);
void QAbstract3DGraph_SelectedElementChanged(void* ptr, long long ty);
void QAbstract3DGraph_ConnectSelectionModeChanged(void* ptr);
void QAbstract3DGraph_DisconnectSelectionModeChanged(void* ptr);
void QAbstract3DGraph_SelectionModeChanged(void* ptr, long long mode);
void QAbstract3DGraph_SetActiveInputHandler(void* ptr, void* inputHandler);
void QAbstract3DGraph_SetActiveTheme(void* ptr, void* theme);
void QAbstract3DGraph_SetAspectRatio(void* ptr, double ratio);
void QAbstract3DGraph_SetHorizontalAspectRatio(void* ptr, double ratio);
void QAbstract3DGraph_SetLocale(void* ptr, void* locale);
void QAbstract3DGraph_SetMargin(void* ptr, double margin);
void QAbstract3DGraph_SetMeasureFps(void* ptr, char enable);
void QAbstract3DGraph_SetOptimizationHints(void* ptr, long long hints);
void QAbstract3DGraph_SetOrthoProjection(void* ptr, char enable);
void QAbstract3DGraph_SetPolar(void* ptr, char enable);
void QAbstract3DGraph_SetRadialLabelOffset(void* ptr, float offset);
void QAbstract3DGraph_SetReflection(void* ptr, char enable);
void QAbstract3DGraph_SetReflectivity(void* ptr, double reflectivity);
void QAbstract3DGraph_SetSelectionMode(void* ptr, long long mode);
void QAbstract3DGraph_SetShadowQuality(void* ptr, long long quality);
void QAbstract3DGraph_ConnectShadowQualityChanged(void* ptr);
void QAbstract3DGraph_DisconnectShadowQualityChanged(void* ptr);
void QAbstract3DGraph_ShadowQualityChanged(void* ptr, long long quality);
void QAbstract3DGraph_DestroyQAbstract3DGraph(void* ptr);
void QAbstract3DGraph_DestroyQAbstract3DGraphDefault(void* ptr);
void* QAbstract3DGraph_Scene(void* ptr);
void* QAbstract3DGraph_ActiveTheme(void* ptr);
void* QAbstract3DGraph_SelectedAxis(void* ptr);
long long QAbstract3DGraph_SelectedElement(void* ptr);
long long QAbstract3DGraph_OptimizationHints(void* ptr);
long long QAbstract3DGraph_SelectionMode(void* ptr);
long long QAbstract3DGraph_ShadowQuality(void* ptr);
void* QAbstract3DGraph_ActiveInputHandler(void* ptr);
void* QAbstract3DGraph_SelectedCustomItem(void* ptr);
struct QtDataVisualization_PackedList QAbstract3DGraph_Themes(void* ptr);
struct QtDataVisualization_PackedList QAbstract3DGraph_InputHandlers(void* ptr);
struct QtDataVisualization_PackedList QAbstract3DGraph_CustomItems(void* ptr);
void* QAbstract3DGraph_Locale(void* ptr);
void* QAbstract3DGraph_QueriedGraphPosition(void* ptr);
char QAbstract3DGraph_HasContext(void* ptr);
char QAbstract3DGraph_IsOrthoProjection(void* ptr);
char QAbstract3DGraph_IsPolar(void* ptr);
char QAbstract3DGraph_IsReflection(void* ptr);
char QAbstract3DGraph_MeasureFps(void* ptr);
char QAbstract3DGraph_ShadowsSupported(void* ptr);
char QAbstract3DGraph_ShadowsSupportedDefault(void* ptr);
void* QAbstract3DGraph_MetaObject(void* ptr);
void* QAbstract3DGraph_MetaObjectDefault(void* ptr);
float QAbstract3DGraph_RadialLabelOffset(void* ptr);
int QAbstract3DGraph_SelectedCustomItemIndex(void* ptr);
int QAbstract3DGraph_SelectedLabelIndex(void* ptr);
double QAbstract3DGraph_AspectRatio(void* ptr);
double QAbstract3DGraph_CurrentFps(void* ptr);
double QAbstract3DGraph_HorizontalAspectRatio(void* ptr);
double QAbstract3DGraph_Margin(void* ptr);
double QAbstract3DGraph_Reflectivity(void* ptr);
void* QAbstract3DGraph___themes_atList(void* ptr, int i);
void QAbstract3DGraph___themes_setList(void* ptr, void* i);
void* QAbstract3DGraph___themes_newList(void* ptr);
void* QAbstract3DGraph___inputHandlers_atList(void* ptr, int i);
void QAbstract3DGraph___inputHandlers_setList(void* ptr, void* i);
void* QAbstract3DGraph___inputHandlers_newList(void* ptr);
void* QAbstract3DGraph___customItems_atList(void* ptr, int i);
void QAbstract3DGraph___customItems_setList(void* ptr, void* i);
void* QAbstract3DGraph___customItems_newList(void* ptr);
void* QAbstract3DInputHandler_NewQAbstract3DInputHandler(void* parent);
struct QtDataVisualization_PackedString QAbstract3DInputHandler_QAbstract3DInputHandler_Tr(char* s, char* c, int n);
struct QtDataVisualization_PackedString QAbstract3DInputHandler_QAbstract3DInputHandler_TrUtf8(char* s, char* c, int n);
@ -1000,6 +876,7 @@ void QCustom3DVolume_ConnectPreserveOpacityChanged(void* ptr);
void QCustom3DVolume_DisconnectPreserveOpacityChanged(void* ptr);
void QCustom3DVolume_PreserveOpacityChanged(void* ptr, char enabled);
void QCustom3DVolume_SetAlphaMultiplier(void* ptr, float mult);
void QCustom3DVolume_SetColorTable(void* ptr, void* colors);
void QCustom3DVolume_SetDrawSliceFrames(void* ptr, char enable);
void QCustom3DVolume_SetDrawSlices(void* ptr, char enable);
void QCustom3DVolume_SetPreserveOpacity(void* ptr, char enable);
@ -1062,6 +939,7 @@ long long QCustom3DVolume_TextureFormat(void* ptr);
void* QCustom3DVolume_SliceFrameGaps(void* ptr);
void* QCustom3DVolume_SliceFrameThicknesses(void* ptr);
void* QCustom3DVolume_SliceFrameWidths(void* ptr);
struct QtDataVisualization_PackedList QCustom3DVolume_ColorTable(void* ptr);
char QCustom3DVolume_DrawSliceFrames(void* ptr);
char QCustom3DVolume_DrawSlices(void* ptr);
char QCustom3DVolume_PreserveOpacity(void* ptr);
@ -1075,8 +953,14 @@ int QCustom3DVolume_SliceIndexZ(void* ptr);
int QCustom3DVolume_TextureDepth(void* ptr);
int QCustom3DVolume_TextureHeight(void* ptr);
int QCustom3DVolume_TextureWidth(void* ptr);
unsigned int QCustom3DVolume___QCustom3DVolume_colorTable_atList2(void* ptr, int i);
void QCustom3DVolume___QCustom3DVolume_colorTable_setList2(void* ptr, unsigned int i);
void* QCustom3DVolume___QCustom3DVolume_colorTable_newList2(void* ptr);
unsigned int QCustom3DVolume___setColorTable_colors_atList(void* ptr, int i);
void QCustom3DVolume___setColorTable_colors_setList(void* ptr, unsigned int i);
void* QCustom3DVolume___setColorTable_colors_newList(void* ptr);
unsigned int QCustom3DVolume___colorTable_atList(void* ptr, int i);
void QCustom3DVolume___colorTable_setList(void* ptr, unsigned int i);
void* QCustom3DVolume___colorTable_newList(void* ptr);
void* QHeightMapSurfaceDataProxy_NewQHeightMapSurfaceDataProxy(void* parent);
void* QHeightMapSurfaceDataProxy_NewQHeightMapSurfaceDataProxy2(void* image, void* parent);

105
gui/gui.cpp
View file

@ -3499,6 +3499,11 @@ void* QColor_QColor_FromHsvF(double h, double s, double v, double a)
return new QColor(QColor::fromHsvF(h, s, v, a));
}
void* QColor_QColor_FromRgb(unsigned int rgb)
{
return new QColor(QColor::fromRgb(rgb));
}
void* QColor_QColor_FromRgb2(int r, int g, int b, int a)
{
return new QColor(QColor::fromRgb(r, g, b, a));
@ -3509,6 +3514,11 @@ void* QColor_QColor_FromRgbF(double r, double g, double b, double a)
return new QColor(QColor::fromRgbF(r, g, b, a));
}
void* QColor_QColor_FromRgba(unsigned int rgba)
{
return new QColor(QColor::fromRgba(rgba));
}
void* QColor_QColor_FromRgba642(void* rgba64)
{
return new QColor(QColor::fromRgba64(*static_cast<QRgba64*>(rgba64)));
@ -3534,6 +3544,11 @@ void* QColor_NewQColor9(void* name)
return new QColor(*static_cast<QLatin1String*>(name));
}
void* QColor_NewQColor4(unsigned int color)
{
return new QColor(color);
}
void* QColor_NewQColor5(void* rgba64)
{
return new QColor(*static_cast<QRgba64*>(rgba64));
@ -3684,6 +3699,11 @@ void QColor_SetRedF(void* ptr, double red)
static_cast<QColor*>(ptr)->setRedF(red);
}
void QColor_SetRgb2(void* ptr, unsigned int rgb)
{
static_cast<QColor*>(ptr)->setRgb(rgb);
}
void QColor_SetRgb(void* ptr, int r, int g, int b, int a)
{
static_cast<QColor*>(ptr)->setRgb(r, g, b, a);
@ -3694,6 +3714,11 @@ void QColor_SetRgbF(void* ptr, double r, double g, double b, double a)
static_cast<QColor*>(ptr)->setRgbF(r, g, b, a);
}
void QColor_SetRgba(void* ptr, unsigned int rgba)
{
static_cast<QColor*>(ptr)->setRgba(rgba);
}
void QColor_SetRgba64(void* ptr, void* rgba)
{
static_cast<QColor*>(ptr)->setRgba64(*static_cast<QRgba64*>(rgba));
@ -3739,6 +3764,16 @@ long long QColor_Spec(void* ptr)
return static_cast<QColor*>(ptr)->spec();
}
unsigned int QColor_Rgb(void* ptr)
{
return static_cast<QColor*>(ptr)->rgb();
}
unsigned int QColor_Rgba(void* ptr)
{
return static_cast<QColor*>(ptr)->rgba();
}
void* QColor_Rgba64(void* ptr)
{
return new QRgba64(static_cast<QColor*>(ptr)->rgba64());
@ -8170,11 +8205,21 @@ void QImage_InvertPixels(void* ptr, long long mode)
static_cast<QImage*>(ptr)->invertPixels(static_cast<QImage::InvertMode>(mode));
}
void QImage_SetColor(void* ptr, int index, unsigned int colorValue)
{
static_cast<QImage*>(ptr)->setColor(index, colorValue);
}
void QImage_SetColorCount(void* ptr, int colorCount)
{
static_cast<QImage*>(ptr)->setColorCount(colorCount);
}
void QImage_SetColorTable(void* ptr, void* colors)
{
static_cast<QImage*>(ptr)->setColorTable(*static_cast<QVector<QRgb>*>(colors));
}
void QImage_SetDevicePixelRatio(void* ptr, double scaleFactor)
{
static_cast<QImage*>(ptr)->setDevicePixelRatio(scaleFactor);
@ -8251,6 +8296,11 @@ void* QImage_ConvertToFormat(void* ptr, long long format, long long flags)
return new QImage(static_cast<QImage*>(ptr)->convertToFormat(static_cast<QImage::Format>(format), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QImage_ConvertToFormat3(void* ptr, long long format, void* colorTable, long long flags)
{
return new QImage(static_cast<QImage*>(ptr)->convertToFormat(static_cast<QImage::Format>(format), *static_cast<QVector<QRgb>*>(colorTable), static_cast<Qt::ImageConversionFlag>(flags)));
}
void* QImage_Copy(void* ptr, void* rectangle)
{
return new QImage(static_cast<QImage*>(ptr)->copy(*static_cast<QRect*>(rectangle)));
@ -8271,6 +8321,11 @@ void* QImage_CreateHeuristicMask(void* ptr, char clipTight)
return new QImage(static_cast<QImage*>(ptr)->createHeuristicMask(clipTight != 0));
}
void* QImage_CreateMaskFromColor(void* ptr, unsigned int color, long long mode)
{
return new QImage(static_cast<QImage*>(ptr)->createMaskFromColor(color, static_cast<Qt::MaskMode>(mode)));
}
void* QImage_Mirrored(void* ptr, char horizontal, char vertical)
{
return new QImage(static_cast<QImage*>(ptr)->mirrored(horizontal != 0, vertical != 0));
@ -8336,6 +8391,21 @@ void* QImage_Rect(void* ptr)
return ({ QRect tmpValue = static_cast<QImage*>(ptr)->rect(); new QRect(tmpValue.x(), tmpValue.y(), tmpValue.width(), tmpValue.height()); });
}
unsigned int QImage_Color(void* ptr, int i)
{
return static_cast<QImage*>(ptr)->color(i);
}
unsigned int QImage_Pixel(void* ptr, void* position)
{
return static_cast<QImage*>(ptr)->pixel(*static_cast<QPoint*>(position));
}
unsigned int QImage_Pixel2(void* ptr, int x, int y)
{
return static_cast<QImage*>(ptr)->pixel(x, y);
}
void* QImage_Size(void* ptr)
{
return ({ QSize tmpValue = static_cast<QImage*>(ptr)->size(); new QSize(tmpValue.width(), tmpValue.height()); });
@ -8351,6 +8421,11 @@ struct QtGui_PackedString QImage_TextKeys(void* ptr)
return ({ QByteArray t71d2ff = static_cast<QImage*>(ptr)->textKeys().join("|").toUtf8(); QtGui_PackedString { const_cast<char*>(t71d2ff.prepend("WHITESPACE").constData()+10), t71d2ff.size()-10 }; });
}
struct QtGui_PackedList QImage_ColorTable(void* ptr)
{
return ({ QVector<QRgb>* tmpValue = new QVector<QRgb>(static_cast<QImage*>(ptr)->colorTable()); QtGui_PackedList { tmpValue, tmpValue->size() }; });
}
char QImage_AllGray(void* ptr)
{
return static_cast<QImage*>(ptr)->allGray();
@ -8456,18 +8531,48 @@ void* QImage_ToVariant(void* ptr)
return new QVariant(*static_cast<QImage*>(ptr));
}
unsigned int QImage___setColorTable_colors_atList(void* ptr, int i)
{
return ({QRgb tmp = static_cast<QVector<QRgb>*>(ptr)->at(i); if (i == static_cast<QVector<QRgb>*>(ptr)->size()-1) { static_cast<QVector<QRgb>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QImage___setColorTable_colors_setList(void* ptr, unsigned int i)
{
static_cast<QVector<QRgb>*>(ptr)->append(i);
}
void* QImage___setColorTable_colors_newList(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRgb>();
}
unsigned int QImage___convertToFormat_colorTable_atList3(void* ptr, int i)
{
return ({QRgb tmp = static_cast<QVector<QRgb>*>(ptr)->at(i); if (i == static_cast<QVector<QRgb>*>(ptr)->size()-1) { static_cast<QVector<QRgb>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QImage___convertToFormat_colorTable_setList3(void* ptr, unsigned int i)
{
static_cast<QVector<QRgb>*>(ptr)->append(i);
}
void* QImage___convertToFormat_colorTable_newList3(void* ptr)
{
Q_UNUSED(ptr);
return new QVector<QRgb>();
}
unsigned int QImage___colorTable_atList(void* ptr, int i)
{
return ({QRgb tmp = static_cast<QVector<QRgb>*>(ptr)->at(i); if (i == static_cast<QVector<QRgb>*>(ptr)->size()-1) { static_cast<QVector<QRgb>*>(ptr)->~QVector(); free(ptr); }; tmp; });
}
void QImage___colorTable_setList(void* ptr, unsigned int i)
{
static_cast<QVector<QRgb>*>(ptr)->append(i);
}
void* QImage___colorTable_newList(void* ptr)
{
Q_UNUSED(ptr);

172
gui/gui.go
View file

@ -8538,6 +8538,18 @@ func (ptr *QColor) FromHsvF(h float64, s float64, v float64, a float64) *QColor
return tmpValue
}
func QColor_FromRgb(rgb uint) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_QColor_FromRgb(C.uint(uint32(rgb))))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
return tmpValue
}
func (ptr *QColor) FromRgb(rgb uint) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_QColor_FromRgb(C.uint(uint32(rgb))))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
return tmpValue
}
func QColor_FromRgb2(r int, g int, b int, a int) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_QColor_FromRgb2(C.int(int32(r)), C.int(int32(g)), C.int(int32(b)), C.int(int32(a))))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
@ -8562,6 +8574,18 @@ func (ptr *QColor) FromRgbF(r float64, g float64, b float64, a float64) *QColor
return tmpValue
}
func QColor_FromRgba(rgba uint) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_QColor_FromRgba(C.uint(uint32(rgba))))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
return tmpValue
}
func (ptr *QColor) FromRgba(rgba uint) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_QColor_FromRgba(C.uint(uint32(rgba))))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
return tmpValue
}
func QColor_FromRgba642(rgba64 QRgba64_ITF) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_QColor_FromRgba642(PointerFromQRgba64(rgba64)))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
@ -8604,6 +8628,12 @@ func NewQColor9(name core.QLatin1String_ITF) *QColor {
return tmpValue
}
func NewQColor4(color uint) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_NewQColor4(C.uint(uint32(color))))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
return tmpValue
}
func NewQColor5(rgba64 QRgba64_ITF) *QColor {
tmpValue := NewQColorFromPointer(C.QColor_NewQColor5(PointerFromQRgba64(rgba64)))
runtime.SetFinalizer(tmpValue, (*QColor).DestroyQColor)
@ -8817,6 +8847,12 @@ func (ptr *QColor) SetRedF(red float64) {
}
}
func (ptr *QColor) SetRgb2(rgb uint) {
if ptr.Pointer() != nil {
C.QColor_SetRgb2(ptr.Pointer(), C.uint(uint32(rgb)))
}
}
func (ptr *QColor) SetRgb(r int, g int, b int, a int) {
if ptr.Pointer() != nil {
C.QColor_SetRgb(ptr.Pointer(), C.int(int32(r)), C.int(int32(g)), C.int(int32(b)), C.int(int32(a)))
@ -8829,6 +8865,12 @@ func (ptr *QColor) SetRgbF(r float64, g float64, b float64, a float64) {
}
}
func (ptr *QColor) SetRgba(rgba uint) {
if ptr.Pointer() != nil {
C.QColor_SetRgba(ptr.Pointer(), C.uint(uint32(rgba)))
}
}
func (ptr *QColor) SetRgba64(rgba QRgba64_ITF) {
if ptr.Pointer() != nil {
C.QColor_SetRgba64(ptr.Pointer(), PointerFromQRgba64(rgba))
@ -8905,6 +8947,20 @@ func (ptr *QColor) Spec() QColor__Spec {
return 0
}
func (ptr *QColor) Rgb() uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QColor_Rgb(ptr.Pointer())))
}
return 0
}
func (ptr *QColor) Rgba() uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QColor_Rgba(ptr.Pointer())))
}
return 0
}
func (ptr *QColor) Rgba64() *QRgba64 {
if ptr.Pointer() != nil {
tmpValue := NewQRgba64FromPointer(C.QColor_Rgba64(ptr.Pointer()))
@ -18180,12 +18236,30 @@ func (ptr *QImage) InvertPixels(mode QImage__InvertMode) {
}
}
func (ptr *QImage) SetColor(index int, colorValue uint) {
if ptr.Pointer() != nil {
C.QImage_SetColor(ptr.Pointer(), C.int(int32(index)), C.uint(uint32(colorValue)))
}
}
func (ptr *QImage) SetColorCount(colorCount int) {
if ptr.Pointer() != nil {
C.QImage_SetColorCount(ptr.Pointer(), C.int(int32(colorCount)))
}
}
func (ptr *QImage) SetColorTable(colors []uint) {
if ptr.Pointer() != nil {
C.QImage_SetColorTable(ptr.Pointer(), func() unsafe.Pointer {
tmpList := NewQImageFromPointer(NewQImageFromPointer(nil).__setColorTable_colors_newList())
for _, v := range colors {
tmpList.__setColorTable_colors_setList(v)
}
return tmpList.Pointer()
}())
}
}
func (ptr *QImage) SetDevicePixelRatio(scaleFactor float64) {
if ptr.Pointer() != nil {
C.QImage_SetDevicePixelRatio(ptr.Pointer(), C.double(scaleFactor))
@ -18329,6 +18403,21 @@ func (ptr *QImage) ConvertToFormat(format QImage__Format, flags core.Qt__ImageCo
return nil
}
func (ptr *QImage) ConvertToFormat3(format QImage__Format, colorTable []uint, flags core.Qt__ImageConversionFlag) *QImage {
if ptr.Pointer() != nil {
tmpValue := NewQImageFromPointer(C.QImage_ConvertToFormat3(ptr.Pointer(), C.longlong(format), func() unsafe.Pointer {
tmpList := NewQImageFromPointer(NewQImageFromPointer(nil).__convertToFormat_colorTable_newList3())
for _, v := range colorTable {
tmpList.__convertToFormat_colorTable_setList3(v)
}
return tmpList.Pointer()
}(), C.longlong(flags)))
runtime.SetFinalizer(tmpValue, (*QImage).DestroyQImage)
return tmpValue
}
return nil
}
func (ptr *QImage) Copy(rectangle core.QRect_ITF) *QImage {
if ptr.Pointer() != nil {
tmpValue := NewQImageFromPointer(C.QImage_Copy(ptr.Pointer(), core.PointerFromQRect(rectangle)))
@ -18365,6 +18454,15 @@ func (ptr *QImage) CreateHeuristicMask(clipTight bool) *QImage {
return nil
}
func (ptr *QImage) CreateMaskFromColor(color uint, mode core.Qt__MaskMode) *QImage {
if ptr.Pointer() != nil {
tmpValue := NewQImageFromPointer(C.QImage_CreateMaskFromColor(ptr.Pointer(), C.uint(uint32(color)), C.longlong(mode)))
runtime.SetFinalizer(tmpValue, (*QImage).DestroyQImage)
return tmpValue
}
return nil
}
func (ptr *QImage) Mirrored(horizontal bool, vertical bool) *QImage {
if ptr.Pointer() != nil {
tmpValue := NewQImageFromPointer(C.QImage_Mirrored(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(horizontal))), C.char(int8(qt.GoBoolToInt(vertical)))))
@ -18480,6 +18578,27 @@ func (ptr *QImage) Rect() *core.QRect {
return nil
}
func (ptr *QImage) Color(i int) uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QImage_Color(ptr.Pointer(), C.int(int32(i)))))
}
return 0
}
func (ptr *QImage) Pixel(position core.QPoint_ITF) uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QImage_Pixel(ptr.Pointer(), core.PointerFromQPoint(position))))
}
return 0
}
func (ptr *QImage) Pixel2(x int, y int) uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QImage_Pixel2(ptr.Pointer(), C.int(int32(x)), C.int(int32(y)))))
}
return 0
}
func (ptr *QImage) Size() *core.QSize {
if ptr.Pointer() != nil {
tmpValue := core.NewQSizeFromPointer(C.QImage_Size(ptr.Pointer()))
@ -18508,6 +18627,20 @@ func (ptr *QImage) TextKeys() []string {
return make([]string, 0)
}
func (ptr *QImage) ColorTable() []uint {
if ptr.Pointer() != nil {
return func(l C.struct_QtGui_PackedList) []uint {
out := make([]uint, int(l.len))
tmpList := NewQImageFromPointer(l.data)
for i := 0; i < len(out); i++ {
out[i] = tmpList.__colorTable_atList(i)
}
return out
}(C.QImage_ColorTable(ptr.Pointer()))
}
return make([]uint, 0)
}
func (ptr *QImage) AllGray() bool {
if ptr.Pointer() != nil {
return C.QImage_AllGray(ptr.Pointer()) != 0
@ -18672,14 +18805,53 @@ func (ptr *QImage) ToVariant() *core.QVariant {
return nil
}
func (ptr *QImage) __setColorTable_colors_atList(i int) uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QImage___setColorTable_colors_atList(ptr.Pointer(), C.int(int32(i)))))
}
return 0
}
func (ptr *QImage) __setColorTable_colors_setList(i uint) {
if ptr.Pointer() != nil {
C.QImage___setColorTable_colors_setList(ptr.Pointer(), C.uint(uint32(i)))
}
}
func (ptr *QImage) __setColorTable_colors_newList() unsafe.Pointer {
return C.QImage___setColorTable_colors_newList(ptr.Pointer())
}
func (ptr *QImage) __convertToFormat_colorTable_atList3(i int) uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QImage___convertToFormat_colorTable_atList3(ptr.Pointer(), C.int(int32(i)))))
}
return 0
}
func (ptr *QImage) __convertToFormat_colorTable_setList3(i uint) {
if ptr.Pointer() != nil {
C.QImage___convertToFormat_colorTable_setList3(ptr.Pointer(), C.uint(uint32(i)))
}
}
func (ptr *QImage) __convertToFormat_colorTable_newList3() unsafe.Pointer {
return C.QImage___convertToFormat_colorTable_newList3(ptr.Pointer())
}
func (ptr *QImage) __colorTable_atList(i int) uint {
if ptr.Pointer() != nil {
return uint(uint32(C.QImage___colorTable_atList(ptr.Pointer(), C.int(int32(i)))))
}
return 0
}
func (ptr *QImage) __colorTable_setList(i uint) {
if ptr.Pointer() != nil {
C.QImage___colorTable_setList(ptr.Pointer(), C.uint(uint32(i)))
}
}
func (ptr *QImage) __colorTable_newList() unsafe.Pointer {
return C.QImage___colorTable_newList(ptr.Pointer())
}

21
gui/gui.h
View file

@ -511,13 +511,16 @@ void* QColor_QColor_FromHsl(int h, int s, int l, int a);
void* QColor_QColor_FromHslF(double h, double s, double l, double a);
void* QColor_QColor_FromHsv(int h, int s, int v, int a);
void* QColor_QColor_FromHsvF(double h, double s, double v, double a);
void* QColor_QColor_FromRgb(unsigned int rgb);
void* QColor_QColor_FromRgb2(int r, int g, int b, int a);
void* QColor_QColor_FromRgbF(double r, double g, double b, double a);
void* QColor_QColor_FromRgba(unsigned int rgba);
void* QColor_QColor_FromRgba642(void* rgba64);
void* QColor_QColor_FromRgba64(unsigned short r, unsigned short g, unsigned short b, unsigned short a);
void* QColor_NewQColor();
void* QColor_NewQColor12(void* other);
void* QColor_NewQColor9(void* name);
void* QColor_NewQColor4(unsigned int color);
void* QColor_NewQColor5(void* rgba64);
void* QColor_NewQColor7(void* name);
void* QColor_NewQColor2(long long color);
@ -548,8 +551,10 @@ void QColor_SetNamedColor2(void* ptr, void* name);
void QColor_SetNamedColor(void* ptr, struct QtGui_PackedString name);
void QColor_SetRed(void* ptr, int red);
void QColor_SetRedF(void* ptr, double red);
void QColor_SetRgb2(void* ptr, unsigned int rgb);
void QColor_SetRgb(void* ptr, int r, int g, int b, int a);
void QColor_SetRgbF(void* ptr, double r, double g, double b, double a);
void QColor_SetRgba(void* ptr, unsigned int rgba);
void QColor_SetRgba64(void* ptr, void* rgba);
void* QColor_ConvertTo(void* ptr, long long colorSpec);
void* QColor_Darker(void* ptr, int factor);
@ -559,6 +564,8 @@ void* QColor_ToHsl(void* ptr);
void* QColor_ToHsv(void* ptr);
void* QColor_ToRgb(void* ptr);
long long QColor_Spec(void* ptr);
unsigned int QColor_Rgb(void* ptr);
unsigned int QColor_Rgba(void* ptr);
void* QColor_Rgba64(void* ptr);
struct QtGui_PackedString QColor_Name(void* ptr);
struct QtGui_PackedString QColor_Name2(void* ptr, long long format);
@ -1298,7 +1305,9 @@ void QImage_Fill3(void* ptr, long long color);
void QImage_Fill2(void* ptr, void* color);
void QImage_Fill(void* ptr, unsigned int pixelValue);
void QImage_InvertPixels(void* ptr, long long mode);
void QImage_SetColor(void* ptr, int index, unsigned int colorValue);
void QImage_SetColorCount(void* ptr, int colorCount);
void QImage_SetColorTable(void* ptr, void* colors);
void QImage_SetDevicePixelRatio(void* ptr, double scaleFactor);
void QImage_SetDotsPerMeterX(void* ptr, int x);
void QImage_SetDotsPerMeterY(void* ptr, int y);
@ -1314,10 +1323,12 @@ void QImage_DestroyQImageDefault(void* ptr);
void* QImage_PixelColor(void* ptr, void* position);
void* QImage_PixelColor2(void* ptr, int x, int y);
void* QImage_ConvertToFormat(void* ptr, long long format, long long flags);
void* QImage_ConvertToFormat3(void* ptr, long long format, void* colorTable, long long flags);
void* QImage_Copy(void* ptr, void* rectangle);
void* QImage_Copy2(void* ptr, int x, int y, int width, int height);
void* QImage_CreateAlphaMask(void* ptr, long long flags);
void* QImage_CreateHeuristicMask(void* ptr, char clipTight);
void* QImage_CreateMaskFromColor(void* ptr, unsigned int color, long long mode);
void* QImage_Mirrored(void* ptr, char horizontal, char vertical);
void* QImage_RgbSwapped(void* ptr);
void* QImage_Scaled(void* ptr, void* size, long long aspectRatioMode, long long transformMode);
@ -1331,9 +1342,13 @@ long long QImage_Format(void* ptr);
void* QImage_PixelFormat(void* ptr);
void* QImage_Offset(void* ptr);
void* QImage_Rect(void* ptr);
unsigned int QImage_Color(void* ptr, int i);
unsigned int QImage_Pixel(void* ptr, void* position);
unsigned int QImage_Pixel2(void* ptr, int x, int y);
void* QImage_Size(void* ptr);
struct QtGui_PackedString QImage_Text(void* ptr, struct QtGui_PackedString key);
struct QtGui_PackedString QImage_TextKeys(void* ptr);
struct QtGui_PackedList QImage_ColorTable(void* ptr);
char QImage_AllGray(void* ptr);
char QImage_HasAlphaChannel(void* ptr);
char QImage_IsGrayscale(void* ptr);
@ -1355,8 +1370,14 @@ int QImage_PixelIndex2(void* ptr, int x, int y);
long long QImage_CacheKey(void* ptr);
double QImage_DevicePixelRatio(void* ptr);
void* QImage_ToVariant(void* ptr);
unsigned int QImage___setColorTable_colors_atList(void* ptr, int i);
void QImage___setColorTable_colors_setList(void* ptr, unsigned int i);
void* QImage___setColorTable_colors_newList(void* ptr);
unsigned int QImage___convertToFormat_colorTable_atList3(void* ptr, int i);
void QImage___convertToFormat_colorTable_setList3(void* ptr, unsigned int i);
void* QImage___convertToFormat_colorTable_newList3(void* ptr);
unsigned int QImage___colorTable_atList(void* ptr, int i);
void QImage___colorTable_setList(void* ptr, unsigned int i);
void* QImage___colorTable_newList(void* ptr);
void* QImage_PaintEngine(void* ptr);
void* QImage_PaintEngineDefault(void* ptr);

6
internal/binding/converter/helper.go
View file

@ -258,7 +258,11 @@ func IsPrivateSignal(f *parser.Function) bool {
case "windows":
{
if utils.QT_MSYS2() {
fData = utils.LoadOptional(filepath.Join(utils.QT_MSYS2_DIR(), "include", strings.Title(parser.State.ClassMap[f.ClassName()].DocModule), fPath))
if utils.QT_MSYS2_STATIC() {
fData = utils.LoadOptional(filepath.Join(utils.QT_MSYS2_DIR(), "qt5-static", "include", strings.Title(parser.State.ClassMap[f.ClassName()].DocModule), fPath))
} else {
fData = utils.LoadOptional(filepath.Join(utils.QT_MSYS2_DIR(), "include", strings.Title(parser.State.ClassMap[f.ClassName()].DocModule), fPath))
}
} else {
fData = utils.Load(filepath.Join(utils.QT_DIR(), utils.QT_VERSION_MAJOR(), "mingw53_32", "include", strings.Title(parser.State.ClassMap[f.ClassName()].DocModule), fPath))
}

2
internal/binding/parser/class.go
View file

@ -289,7 +289,7 @@ func (c *Class) IsSupported() bool {
"QtDwmApiDll", "QWinMime",
"QAbstract3DGraph":
"QAbstract3DGraph": //TODO: only for arch with pkg_config
{
c.Access = "unsupported_isBlockedClass"
return false

3
internal/binding/parser/class_add.go
View file

@ -140,9 +140,11 @@ func (c *Class) addGeneralFuncs() {
Signature: "()",
})
}
case "QVideoFrame":
{
//QImage qt_imageFromVideoFrame(const QVideoFrame &frame)
/* requires multimedia-private
c.Functions = append(c.Functions, &Function{
Name: "qt_imageFromVideoFrame",
Fullname: fmt.Sprintf("%v::qt_imageFromVideoFrame", c.Name),
@ -157,6 +159,7 @@ func (c *Class) addGeneralFuncs() {
},
Signature: "(const QVideoFrame &frame)",
})
*/
}
}

25
internal/binding/templater/template_cgo_qmake.go
View file

@ -100,7 +100,7 @@ func isAlreadyCached(module, path, target string, mode int, libs []string) bool
}
}
if !strings.Contains(file, utils.QT_VERSION()) {
if !strings.Contains(file, utils.QT_VERSION()) && strings.Contains(file, "5.") {
utils.Log.Debugln("wrong cgo file qt version, re-creating ...")
return false
}
@ -135,24 +135,32 @@ func isAlreadyCached(module, path, target string, mode int, libs []string) bool
}
}
containsPath := func(file, path string) bool {
r := strings.Contains(strings.Replace(strings.Replace(file, "\\", "", -1), "/", "", -1), strings.Replace(strings.Replace(strings.TrimPrefix(path, filepath.VolumeName(path)), "\\", "", -1), "/", "", -1))
if !r {
utils.Log.Debugln("wrong qt path, re-creating ...")
}
return r
}
switch target {
case "darwin", "linux", "windows", "ubports":
//TODO: msys pkg-config mxe brew
switch {
case utils.QT_HOMEBREW(), utils.QT_MACPORTS(), utils.QT_NIX():
return strings.Contains(file, utils.QT_DARWIN_DIR())
return containsPath(file, utils.QT_DARWIN_DIR())
case utils.QT_MSYS2():
return strings.Contains(file, utils.QT_MSYS2_DIR())
return containsPath(file, utils.QT_MSYS2_DIR())
default:
return strings.Contains(file, utils.QT_DIR()) || strings.Contains(file, utils.QT_MXE_TRIPLET())
return containsPath(file, utils.QT_DIR()) || strings.Contains(file, utils.QT_MXE_TRIPLET())
}
case "android", "android-emulator":
return strings.Contains(file, utils.QT_DIR()) && strings.Contains(file, utils.ANDROID_NDK_DIR())
return containsPath(file, utils.QT_DIR()) && strings.Contains(file, utils.ANDROID_NDK_DIR())
case "ios", "ios-simulator":
return strings.Contains(file, utils.QT_DIR()) || strings.Contains(file, utils.QT_DARWIN_DIR())
return containsPath(file, utils.QT_DIR()) || strings.Contains(file, utils.QT_DARWIN_DIR())
case "sailfish", "sailfish-emulator", "asteroid":
case "rpi1", "rpi2", "rpi3":
return strings.Contains(file, strings.TrimSpace(utils.RunCmd(exec.Command(utils.ToolPath("qmake", target), "-query", "QT_INSTALL_LIBS"), fmt.Sprintf("query lib path for %v on %v", target, runtime.GOOS))))
return containsPath(file, strings.TrimSpace(utils.RunCmd(exec.Command(utils.ToolPath("qmake", target), "-query", "QT_INSTALL_LIBS"), fmt.Sprintf("query lib path for %v on %v", target, runtime.GOOS))))
case "js":
}
}
@ -176,9 +184,6 @@ func createProject(module, path, target string, mode int, libs []string) {
if v == "Speech" {
out[i] = "TextToSpeech"
}
if v == "Multimedia" {
out = append(out, "multimedia-private")
}
out[i] = strings.ToLower(out[i])
}

9
internal/binding/templater/template_cpp.go
View file

@ -498,7 +498,7 @@ func preambleCpp(module string, input []byte, mode int, target, tags string) []b
#define private public
#include "%v.h"
%v%v
%v
`,
buildTags(module, false, mode, tags),
@ -544,13 +544,6 @@ func preambleCpp(module string, input []byte, mode int, target, tags string) []b
return "#include \"_cgo_export.h\""
}
}(),
func() string {
if module == "QtMultimedia" {
return "\n#include \"private/qvideoframe_p.h\""
}
return ""
}(),
)
var classes = make([]string, 0)

42
internal/ci/iscript.qs
View file

@ -34,38 +34,44 @@ Controller.prototype.TargetDirectoryPageCallback = function()
Controller.prototype.ComponentSelectionPageCallback = function()
{
var version = "5111";
if (installer.value("VERSION") != "")
{
version = installer.value("VERSION");
}
if (installer.value("DARWIN") == "true")
{
gui.currentPageWidget().selectComponent("qt.qt5.5111.clang_64");
}
gui.currentPageWidget().selectComponent("qt.qt5."+version+".clang_64");
}
if (installer.value("IOS") == "true")
{
gui.currentPageWidget().selectComponent("qt.qt5.5111.ios");
}
gui.currentPageWidget().selectComponent("qt.qt5."+version+".ios");
}
if (installer.value("WINDOWS") == "true")
{
gui.currentPageWidget().selectComponent("qt.qt5.5111.win32_mingw53");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".win32_mingw53");
}
if (installer.value("LINUX") == "true")
{
gui.currentPageWidget().selectComponent("qt.qt5.5111.gcc_64");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".gcc_64");
}
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtvirtualkeyboard");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtscript");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtremoteobjects");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtpurchasing");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtnetworkauth");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtdatavis3d");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtcharts");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtwebengine");
gui.currentPageWidget().selectComponent("qt.qt5.5111.qtwebglplugin");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtvirtualkeyboard");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtscript");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtremoteobjects");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtpurchasing");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtnetworkauth");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtdatavis3d");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtcharts");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtwebengine");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".qtwebglplugin");
gui.currentPageWidget().selectComponent("qt.qt5.5111.android_armv7");
gui.currentPageWidget().selectComponent("qt.qt5.5111.android_x86");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".android_armv7");
gui.currentPageWidget().selectComponent("qt.qt5."+version+".android_x86");
gui.clickButton(buttons.NextButton);
}
@ -88,7 +94,7 @@ Controller.prototype.ReadyForInstallationPageCallback = function()
Controller.prototype.FinishedPageCallback = function()
{
var checkBox = gui.currentPageWidget().LaunchQtCreatorCheckBoxForm
var checkBox = gui.currentPageWidget().LaunchQtCreatorCheckBoxForm;
if (checkBox && checkBox.launchQtCreatorCheckBox)
{
checkBox.launchQtCreatorCheckBox.checked = false;

4
internal/cmd/cmd.go
View file

@ -461,6 +461,10 @@ func BuildEnv(target, name, depPath string) (map[string]string, []string, []stri
"CGO_ENABLED": "1",
}
if utils.QT_VERSION_NUM() <= 5051 {
env["CGO_CXXFLAGS"] = "-std=c++11"
}
if arm, ok := os.LookupEnv("GOARM"); ok {
env["GOARM"] = arm
env["CC"] = os.Getenv("CC")

6
internal/cmd/deploy/bundle.go
View file

@ -231,7 +231,9 @@ func bundle(mode, target, path, name, depPath string) {
for lib, deps := range parser.LibDeps {
if strings.Contains(output, lib) && lib != parser.MOC {
for _, lib := range append(deps, lib) {
utils.RunCmd(exec.Command("cp", filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib)), depPath), fmt.Sprintf("copy %v for %v on %v", lib, target, runtime.GOOS))
if utils.ExistsFile(filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib))) && !utils.ExistsFile(filepath.Join(depPath, fmt.Sprintf("Qt5%v.dll", lib))) {
utils.RunCmd(exec.Command("cp", filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib)), depPath), fmt.Sprintf("copy %v for %v on %v", lib, target, runtime.GOOS))
}
}
}
}
@ -288,7 +290,7 @@ func bundle(mode, target, path, name, depPath string) {
for lib, deps := range parser.LibDeps {
if strings.Contains(output, lib) && lib != parser.MOC {
for _, lib := range append(deps, lib) {
if utils.ExistsFile(filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib))) {
if utils.ExistsFile(filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib))) && !utils.ExistsFile(filepath.Join(depPath, fmt.Sprintf("Qt5%v.dll", lib))) {
if utils.MSYSTEM() != "" {
utils.RunCmd(exec.Command(copyCmd, filepath.Join(libraryPath, fmt.Sprintf("Qt5%v.dll", lib)), depPath), fmt.Sprintf("copy %v for %v on %v", lib, target, runtime.GOOS))
} else {

4
internal/cmd/minimal/minimal.go
View file

@ -2,6 +2,7 @@ package minimal
import (
"fmt"
"path/filepath"
"strconv"
"strings"
"sync"
@ -46,6 +47,9 @@ func Minimal(path, target, tags string) {
wc <- true
go func(path string) {
for _, path := range cmd.GetGoFiles(path, target, tags) {
if base := filepath.Base(path); strings.HasPrefix(base, "rcc_cgo") || strings.HasPrefix(base, "moc_cgo") {
continue
}
utils.Log.WithField("path", path).Debug("analyse for minimal")
file := utils.Load(path)
fileMutex.Lock()

10
internal/cmd/moc/moc.go
View file

@ -349,19 +349,25 @@ func moc(path, target, tags string, fast, slow, root bool, l int) {
}
func parse(path string) ([]*parser.Class, string, error) {
utils.Log.WithField("path", path).Debug("parse")
if base := filepath.Base(path); strings.HasPrefix(base, "rcc") || strings.HasPrefix(base, "moc") {
return nil, "", errors.New("file contains no moc structs")
}
if strings.HasPrefix(path, filepath.Join(runtime.GOROOT(), "src")) {
return nil, "", errors.New("path is in GOROOT/src")
}
utils.Log.WithField("path", path).Debug("parse")
src, err := ioutil.ReadFile(path)
if err != nil {
utils.Log.WithField("path", path).WithError(err).Debug("failed to read file")
return nil, "", err
}
file, err := goparser.ParseFile(token.NewFileSet(), path, nil, 0)
if err != nil {
utils.Log.WithField("path", path).WithError(err).Debug("failed to parse file")
return nil, "", err
}
@ -764,7 +770,7 @@ func parseNonMocDeps(files []string) {
wc := make(chan bool, 50)
for _, fpath := range files {
if filepath.Base(fpath) == "moc.go" {
if base := filepath.Base(fpath); strings.HasPrefix(base, "rcc") || strings.HasPrefix(base, "moc") {
continue
}

23
internal/cmd/utils.go
View file

@ -7,8 +7,6 @@ import (
"strings"
"sync"
iparser "github.com/therecipe/qt/internal/binding/parser"
"github.com/therecipe/qt/internal/utils"
)
@ -58,7 +56,8 @@ func GetImports(path, target, tagsCustom string, level int, onlyDirect, moc bool
imp = "Imports"
}
cmd := exec.Command("go", "list", "-e", "-f", "'{{ join .TestImports \"|\" }}':'{{ join ."+imp+" \"|\" }}'", fmt.Sprintf("-tags=\"%v\"", strings.Join(tags, "\" \"")))
//TODO: cache
cmd := exec.Command("go", "list", "-e", "-f", "'{{ join .TestImports \"|\" }}':'{{ join .XTestImports \"|\" }}':'{{ join ."+imp+" \"|\" }}'", fmt.Sprintf("-tags=\"%v\"", strings.Join(tags, "\" \"")))
cmd.Dir = path
for k, v := range env {
cmd.Env = append(cmd.Env, fmt.Sprintf("%v=%v", k, v))
@ -92,7 +91,6 @@ func GetImports(path, target, tagsCustom string, level int, onlyDirect, moc bool
}
}
libDepsMutex := new(sync.Mutex)
wg := new(sync.WaitGroup)
wc := make(chan bool, 50)
wg.Add(len(libs))
@ -104,6 +102,10 @@ func GetImports(path, target, tagsCustom string, level int, onlyDirect, moc bool
wg.Done()
}()
if strings.Contains(l, "github.com/therecipe/qt") && !strings.Contains(l, "qt/internal") {
return
}
cmd := exec.Command("go", "list", "-e", "-f", "{{.Dir}}", fmt.Sprintf("-tags=\"%v\"", strings.Join(tags, "\" \"")), l)
for k, v := range env {
cmd.Env = append(cmd.Env, fmt.Sprintf("%v=%v", k, v))
@ -114,16 +116,6 @@ func GetImports(path, target, tagsCustom string, level int, onlyDirect, moc bool
return
}
if strings.Contains(dep, filepath.Join("github.com", "therecipe", "qt")) && !strings.Contains(dep, filepath.Join("qt", "internal")) {
return
}
if strings.Contains(dep, filepath.Join("github.com", "therecipe", "qt", "q")) {
libDepsMutex.Lock()
iparser.LibDeps[iparser.MOC] = append(iparser.LibDeps[iparser.MOC], "Qml")
libDepsMutex.Unlock()
}
importedMutex.Lock()
importMap[dep] = struct{}{}
imported[l] = dep
@ -147,7 +139,8 @@ func GetGoFiles(path, target, tagsCustom string) []string {
tags = append(tags, strings.Split(tagsCustom, " ")...)
}
cmd := exec.Command("go", "list", "-e", "-f", "'{{ join .GoFiles \"|\" }}':'{{ join .CgoFiles \"|\" }}':'{{ join .TestGoFiles \"|\" }}'", fmt.Sprintf("-tags=\"%v\"", strings.Join(tags, "\" \"")))
//TODO: cache
cmd := exec.Command("go", "list", "-e", "-f", "'{{ join .GoFiles \"|\" }}':'{{ join .CgoFiles \"|\" }}':'{{ join .TestGoFiles \"|\" }}':'{{ join .XTestGoFiles \"|\" }}'", fmt.Sprintf("-tags=\"%v\"", strings.Join(tags, "\" \"")))
cmd.Dir = path
for k, v := range env {
cmd.Env = append(cmd.Env, fmt.Sprintf("%v=%v", k, v))

3
internal/docker/linux/Dockerfile
View file

@ -3,14 +3,13 @@ FROM ubuntu:16.04 as base
ENV USER user
ENV HOME /home/$USER
ENV GOPATH $HOME/work
ENV QT_QPA_PLATFORM minimal
RUN apt-get -qq update && apt-get --no-install-recommends -qq -y install ca-certificates curl git
RUN GO=go1.11.1.linux-amd64.tar.gz && curl -sL --retry 10 --retry-delay 10 -O https://storage.googleapis.com/golang/$GO && tar -xzf $GO -C /usr/local
RUN /usr/local/go/bin/go get github.com/therecipe/qt/cmd/...
RUN apt-get -qq update && apt-get --no-install-recommends -qq -y install dbus fontconfig libx11-6 libx11-xcb1
RUN QT=qt-unified-linux-x64-online.run && curl -sL --retry 10 --retry-delay 10 -O https://download.qt.io/official_releases/online_installers/$QT && chmod +x $QT && ./$QT --script $GOPATH/src/github.com/therecipe/qt/internal/ci/iscript.qs LINUX=true
RUN QT=qt-unified-linux-x64-online.run && curl -sL --retry 10 --retry-delay 10 -O https://download.qt.io/official_releases/online_installers/$QT && chmod +x $QT && QT_QPA_PLATFORM=minimal ./$QT --script $GOPATH/src/github.com/therecipe/qt/internal/ci/iscript.qs LINUX=true
RUN find /opt/Qt/5.11.1 -type f -name "*.debug" -delete
RUN find /opt/Qt/Docs -type f ! -name "*.index" -delete

3
internal/utils/darwin.go
View file

@ -73,7 +73,8 @@ func QT_MACPORTS() bool {
}
func QT_NIX() bool {
return len(os.Getenv("NIX_STORE")) != 0
_, ok := os.LookupEnv("NIX_STORE")
return ok
}
func isHomeBrewQtDir() bool {

20
internal/utils/env.go
View file

@ -60,18 +60,21 @@ func qT_DIR() string {
if dir, ok := os.LookupEnv("QT_DIR"); ok {
return filepath.Clean(dir)
}
prefix := os.Getenv("HOME")
if runtime.GOOS == "windows" {
dir := "C:\\Qt"
if ExistsDir(dir) {
return dir
}
return dir + "\\Qt" + QT_VERSION()
prefix = "C:\\"
}
dir := filepath.Join(os.Getenv("HOME"), "Qt")
if ExistsDir(dir) {
if dir := filepath.Join(prefix, "Qt", "Qt"+QT_VERSION()); ExistsDir(dir) {
return dir
}
return dir + QT_VERSION()
if dir := filepath.Join(prefix, "Qt"+QT_VERSION()); ExistsDir(dir) {
return dir
}
return filepath.Join(prefix, "Qt")
}
func QT_FAT() bool {
@ -190,6 +193,7 @@ func ToolPath(tool, target string) string {
return ""
}
//TODO: detect webkit support automatically
func QT_WEBKIT() bool {
return os.Getenv("QT_WEBKIT") == "true"
}

8
internal/utils/gopath.go
View file

@ -6,11 +6,13 @@ import (
"path/filepath"
"runtime"
"strings"
"sync"
)
const packageName = "github.com/therecipe/qt"
var mustGoPath string
var mustGoPathMutex = new(sync.Mutex)
//GOBIN returns the general GOBIN string
func GOBIN() string {
@ -23,9 +25,11 @@ func GOBIN() string {
// MustGoPath returns the GOPATH that holds this package
// it exits if any error occurres and also caches the result
func MustGoPath() string {
if mustGoPath == "" {
mustGoPath = strings.TrimSpace(RunCmd(exec.Command(filepath.Join(runtime.GOROOT(), "bin", "go"), "list", "-f", "{{.Root}}", "github.com/therecipe/qt"), "get list gopath"))
mustGoPathMutex.Lock()
if len(mustGoPath) == 0 {
mustGoPath = strings.TrimSpace(RunCmd(exec.Command("go", "list", "-f", "{{.Root}}", "github.com/therecipe/qt"), "get list gopath"))
}
mustGoPathMutex.Unlock()
return mustGoPath
}

2
internal/vagrant/pre.bat
View file

@ -36,7 +36,7 @@ set GO=go1.11.1.windows-amd64.msi
curl -sL --retry 10 --retry-delay 10 -o %TMP%\%GO% https://storage.googleapis.com/golang/%GO%
%TMP%\%GO% /passive /norestart
del %TMP%\%GO% /Q
reg delete "HKCU\Environment" /v GOPATH /f
reg delete "HKEY_CURRENT_USER\Environment" /v GOPATH /f
setx /M PATH "%PATH%;C:\Go\bin"
set PATH=%PATH%;C:\Go\bin
setx /M GOPATH "C:\gopath"

6
multimedia/multimedia.cpp
View file

@ -5,7 +5,6 @@
#include "multimedia.h"
#include "_cgo_export.h"
#include "private/qvideoframe_p.h"
#include <QAbstractAudioDeviceInfo>
#include <QAbstractAudioInput>
@ -20677,11 +20676,6 @@ long long QVideoFrame_StartTime(void* ptr)
return static_cast<QVideoFrame*>(ptr)->startTime();
}
void* QVideoFrame_QVideoFrame_Qt_imageFromVideoFrame(void* frame)
{
return new QImage(qt_imageFromVideoFrame(*static_cast<QVideoFrame*>(frame)));
}
void* QVideoFrame___availableMetaData_atList(void* ptr, struct QtMultimedia_PackedString v, int i)
{
return new QVariant(({ QVariant tmp = static_cast<QMap<QString, QVariant>*>(ptr)->value(QString::fromUtf8(v.data, v.len)); if (i == static_cast<QMap<QString, QVariant>*>(ptr)->size()-1) { static_cast<QMap<QString, QVariant>*>(ptr)->~QMap(); free(ptr); }; tmp; }));

12
multimedia/multimedia.go
View file

@ -43784,18 +43784,6 @@ func (ptr *QVideoFrame) StartTime() int64 {
return 0
}
func QVideoFrame_Qt_imageFromVideoFrame(frame QVideoFrame_ITF) *gui.QImage {
tmpValue := gui.NewQImageFromPointer(C.QVideoFrame_QVideoFrame_Qt_imageFromVideoFrame(PointerFromQVideoFrame(frame)))
runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
return tmpValue
}
func (ptr *QVideoFrame) Qt_imageFromVideoFrame(frame QVideoFrame_ITF) *gui.QImage {
tmpValue := gui.NewQImageFromPointer(C.QVideoFrame_QVideoFrame_Qt_imageFromVideoFrame(PointerFromQVideoFrame(frame)))
runtime.SetFinalizer(tmpValue, (*gui.QImage).DestroyQImage)
return tmpValue
}
func (ptr *QVideoFrame) __availableMetaData_atList(v string, i int) *core.QVariant {
if ptr.Pointer() != nil {
var vC *C.char

1
multimedia/multimedia.h
View file

@ -2752,7 +2752,6 @@ int QVideoFrame_PlaneCount(void* ptr);
int QVideoFrame_Width(void* ptr);
long long QVideoFrame_EndTime(void* ptr);
long long QVideoFrame_StartTime(void* ptr);
void* QVideoFrame_QVideoFrame_Qt_imageFromVideoFrame(void* frame);
void* QVideoFrame___availableMetaData_atList(void* ptr, struct QtMultimedia_PackedString v, int i);
void QVideoFrame___availableMetaData_setList(void* ptr, struct QtMultimedia_PackedString key, void* i);
void* QVideoFrame___availableMetaData_newList(void* ptr);