Revision control
Copy as Markdown
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include <QtGraphsWidgets/q3dgraphswidgetitem.h>
#include <private/q3dgraphswidgetitem_p.h>
#include <private/q3dscene_p.h>
#include <private/qquickgraphsitem_p.h>
#ifdef Q_OS_DARWIN
#include <QtQuick3D/qquick3d.h>
#endif
QT_BEGIN_NAMESPACE
/*!
* \class Q3DGraphsWidgetItem
* \inmodule QtGraphsWidgets
* \ingroup graphs_3D_widgets
* \brief The Q3DGraphsWidgetItem class provides a window and render loop for
* graphs.
*
* This class subclasses a QWindow and provides render loop for graphs
* inheriting it.
*
* You should not need to use this class directly, but one of its subclasses
* instead.
*
* Multisampling is turned off by default in \c {QSurfaceFormat}.
* To enable multisampling, set a custom surface format as
* a default surface format. To get the custom surface format,
* use \l {QQuick3D::idealSurfaceFormat()}.
*
* \sa Q3DBarsWidgetItem, Q3DScatterWidgetItem, Q3DSurfaceWidgetItem, {Qt Graphs C++ Classes for 3D}
*/
/*!
* \internal
*/
Q3DGraphsWidgetItem::Q3DGraphsWidgetItem(Q3DGraphsWidgetItemPrivate &dd,
QObject *parent,
const QString &graphType)
: QObject(dd, parent)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphType = graphType;
}
/*!
* Destroys Q3DGraphsWidgetItem.
*/
Q3DGraphsWidgetItem::~Q3DGraphsWidgetItem()
{
}
/*!
* Adds the given \a theme to the graph. The themes added via addTheme are not
* taken in to use directly. Only the ownership of the theme is given to the
* graph. The \a theme must not be null or already added to another graph.
*
* \sa releaseTheme(), setActiveTheme()
*/
void Q3DGraphsWidgetItem::addTheme(QGraphsTheme *theme)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->addTheme(theme);
}
/*!
* Releases the ownership of the \a theme back to the caller, if it was added to
* this graph. If the released \a theme is in use, a new default theme will be
* created and set active.
*
* If the default theme is released and added back later, it behaves as any
* other theme would.
*
* \sa addTheme(), setActiveTheme()
*/
void Q3DGraphsWidgetItem::releaseTheme(QGraphsTheme *theme)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->releaseTheme(theme);
}
/*!
* \property Q3DGraphsWidgetItem::activeTheme
*
* \brief The active theme of the graph.
*
* Sets \a activeTheme as the active theme to be used for the graph. Implicitly
* calls addTheme() to transfer the ownership of the theme to this graph.
*
* If \a activeTheme is null, a temporary default theme is created. This
* temporary theme is destroyed if any theme is explicitly set later. Properties
* of the theme can be modified even after setting it, and the modifications
* take effect immediately.
*/
QGraphsTheme *Q3DGraphsWidgetItem::activeTheme() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->theme();
}
void Q3DGraphsWidgetItem::setActiveTheme(QGraphsTheme *activeTheme)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setTheme(activeTheme);
}
/*!
* Returns the list of all added themes.
*
* \sa addTheme()
*/
QList<QGraphsTheme *> Q3DGraphsWidgetItem::themes() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->themes();
}
/*!
* \property Q3DGraphsWidgetItem::transparencyTechnique
* \since 6.9
*
* \brief Specifies which transparency technique to use. The Default value is \c{Default}.
* When rendering transparent surface graphs, use \c{Approximate} or \c{Accurate}.
* \c Default should be used for other graph types.
*
* \value Default
* Indicates that order-independent transparency techniques are not used.
* Offers the best performance. Use when graphs don't contain
* transparency or when a bar or scatter graph is also using instancing,
* that is \l optimizationHint is {QtGraphs3D::OptimizationHint::Default}.
*
* \value Approximate
* Indicates that a graph attempts an approximation of order-independent
* transparency. This method is faster than \c Accurate and works on older
* hardware but may yield inaccurate results. Use when the order-independent
* transparency is needed, but the performance cost has to be lower than
* when using accurate order-independent transparency.
*
* \value Accurate
* Indicates that accurate order-independent transparency is used.
* Use when perfect transparency rendering is needed.
*
* \sa QtGraphs3D::TransparencyTechnique
*/
QtGraphs3D::TransparencyTechnique Q3DGraphsWidgetItem::transparencyTechnique() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->transparencyTechnique();
}
void Q3DGraphsWidgetItem::setTransparencyTechnique(QtGraphs3D::TransparencyTechnique technique)
{
Q_D(const Q3DGraphsWidgetItem);
d->m_graphsItem->setTransparencyTechnique(technique);
}
/*!
* \property Q3DGraphsWidgetItem::selectionMode
*
* \brief Item selection mode.
*
* A combination of SelectionFlags. By default, \c Item.
* Different graph types support different selection modes.
*
* \sa QtGraphs3D::SelectionFlags
*/
QtGraphs3D::SelectionFlags Q3DGraphsWidgetItem::selectionMode() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->selectionMode();
}
void Q3DGraphsWidgetItem::setSelectionMode(const QtGraphs3D::SelectionFlags &selectionMode)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setSelectionMode(selectionMode);
}
/*!
* \property Q3DGraphsWidgetItem::shadowQuality
*
* \brief The quality of the shadow.
*
* One of the ShadowQuality enum values. By default, \c Medium.
*
* \note If setting the shadow quality to a certain level fails, the level is
* lowered until it is successfully set. The \c shadowQualityChanged signal is
* emitted each time a change is made.
*
* \sa QtGraphs3D::ShadowQuality
*/
QtGraphs3D::ShadowQuality Q3DGraphsWidgetItem::shadowQuality() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->shadowQuality();
}
void Q3DGraphsWidgetItem::setShadowQuality(const QtGraphs3D::ShadowQuality &shadowQuality)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setShadowQuality(shadowQuality);
}
/*!
* \property Q3DGraphsWidgetItem::scene
* \readonly
*
* \brief The Q3DScene pointer that can be used to manipulate the scene and
* access the scene elements.
*
* This property is read-only.
*/
Q3DScene *Q3DGraphsWidgetItem::scene() const
{
Q_D(const Q3DGraphsWidgetItem);
return (Q3DScene *) d->m_graphsItem->scene();
}
/*!
* Clears selection from all attached series.
*/
void Q3DGraphsWidgetItem::clearSelection()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->clearSelection();
}
/*!
* Returns whether the \a series has already been added to the graph.
*/
bool Q3DGraphsWidgetItem::hasSeries(QAbstract3DSeries *series) const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->hasSeries(series);
}
/*!
* Adds a QCustom3DItem \a item to the graph. Graph takes ownership of the added
* item.
*
* Returns the index to the added item if the add operation was successful, -1
* if trying to add a null item, and the index of the item if trying to add an
* already added item.
*
* Items are rendered in the order they have been inserted. The rendering order
* needs to be taken into account when having solid and transparent items.
*
* \sa removeCustomItems(), removeCustomItem(), removeCustomItemAt(),
* customItems()
*/
qsizetype Q3DGraphsWidgetItem::addCustomItem(QCustom3DItem *item)
{
Q_D(Q3DGraphsWidgetItem);
return d->m_graphsItem->addCustomItem(item);
}
/*!
* Removes all custom items. Deletes the resources allocated to them.
*/
void Q3DGraphsWidgetItem::removeCustomItems()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->removeCustomItems();
}
/*!
* Removes the custom \a {item}. Deletes the resources allocated to it.
*/
void Q3DGraphsWidgetItem::removeCustomItem(QCustom3DItem *item)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->removeCustomItem(item);
}
/*!
* Removes all custom items at \a {position}. Deletes the resources allocated to
* them.
*/
void Q3DGraphsWidgetItem::removeCustomItemAt(QVector3D position)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->removeCustomItemAt(position);
}
/*!
* Gets ownership of given \a item back and removes the \a item from the graph.
*
* \note If the same item is added back to the graph, the texture or the texture
* file needs to be re-set.
*
* \sa QCustom3DItem::setTextureImage(), QCustom3DItem::setTextureFile()
*/
void Q3DGraphsWidgetItem::releaseCustomItem(QCustom3DItem *item)
{
Q_D(Q3DGraphsWidgetItem);
return d->m_graphsItem->releaseCustomItem(item);
}
/*!
* Returns the list of all added custom items.
* \sa addCustomItem()
*/
QList<QCustom3DItem *> Q3DGraphsWidgetItem::customItems() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->customItems();
}
/*!
* Can be used to query the index of the selected label after receiving \c
* selectedElementChanged signal with any label type. Selection is valid until
* the next \c selectedElementChanged signal.
*
* Returns the index of the selected label, or -1.
*
* \sa selectedElement
*/
int Q3DGraphsWidgetItem::selectedLabelIndex() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->selectedLabelIndex();
}
/*!
* Can be used to get the selected axis after receiving \c
* selectedElementChanged signal with any label type. Selection is valid until
* the next \c selectedElementChanged signal.
*
* Returns the pointer to the selected axis, or null.
*
* \sa selectedElement
*/
QAbstract3DAxis *Q3DGraphsWidgetItem::selectedAxis() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->selectedAxis();
}
/*!
* Can be used to query the index of the selected custom item after receiving \c
* selectedElementChanged signal with Q3DGraphsWidgetItem::ElementType::CustomItem
* type. Selection is valid until the next \c selectedElementChanged signal.
*
* Returns the index of the selected custom item, or -1.
*
* \sa selectedElement
*/
qsizetype Q3DGraphsWidgetItem::selectedCustomItemIndex() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->selectedCustomItemIndex();
}
/*!
* Can be used to get the selected custom item after receiving \c
* selectedElementChanged signal with Q3DGraphsWidgetItem::ElementType::CustomItem
* type. Ownership of the item remains with the graph. Selection is valid until
* the next \c selectedElementChanged signal.
*
* Returns the pointer to the selected custom item, or null.
*
* \sa selectedElement
*/
QCustom3DItem *Q3DGraphsWidgetItem::selectedCustomItem() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->selectedCustomItem();
}
/*!
* \property Q3DGraphsWidgetItem::selectedElement
* \readonly
*
* \brief The element selected in the graph.
*
* This property can be used to query the selected element type. The type is
* valid until a new selection is made in the graph and the
* \c selectedElementChanged signal is emitted.
*
* The signal can be used for example for implementing custom input handlers, as
* demonstrated in the \l {Graph Gallery} example under \uicontrol {Scatter
* Graph} tab.
*
* \sa selectedLabelIndex(), selectedAxis(), selectedCustomItemIndex(),
* selectedCustomItem(), Q3DBarsWidgetItem::selectedSeries(),
* Q3DScatterWidgetItem::selectedSeries(), Q3DSurfaceWidgetItem::selectedSeries(),
* Q3DScene::setSelectionQueryPosition()
*/
QtGraphs3D::ElementType Q3DGraphsWidgetItem::selectedElement() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->selectedElement();
}
/*!
* Renders current frame to an image of \a imageSize.
* Returns a shared pointer to grab result which can be used to access the
* rendered image when it's ready. Image is rendered with the current
* antialiasing settings.
*
* \sa QQuickItem::grabToImage()
*/
QSharedPointer<QQuickItemGrabResult> Q3DGraphsWidgetItem::renderToImage(QSize imageSize) const
{
QSize renderSize = imageSize;
Q_D(const Q3DGraphsWidgetItem);
if (renderSize.isEmpty())
renderSize = d->m_widget->size();
return d->m_graphsItem->grabToImage(renderSize);
}
/*!
\property Q3DGraphsWidgetItem::cameraPreset
The preset camera position that the camera is currently using. The value can be set to one of the
CameraPreset enum values. This property can be used to set a predefined camera angle from where
the graph is viewed.
By default, the camera preset is set to \c CameraPreset::FrontLow.
\note If you have set the cameraXRotation, cameraYRotation or cameraZoomLevel properties, or
called setCustomCamera(), this property will return CameraPreset::NoPreset until either
setCameraPreset() is called again, or the preset is changed to another value.
*/
QtGraphs3D::CameraPreset Q3DGraphsWidgetItem::cameraPreset() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->cameraPreset();
}
void Q3DGraphsWidgetItem::setCameraPreset(QtGraphs3D::CameraPreset preset)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setCameraPreset(preset);
}
/*!
* \property Q3DGraphsWidgetItem::cameraXRotation
*
* \brief The X-rotation angle of the camera around the target point in degrees.
*/
float Q3DGraphsWidgetItem::cameraXRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->cameraXRotation();
}
void Q3DGraphsWidgetItem::setCameraXRotation(float rotation)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setCameraXRotation(rotation);
}
/*!
* \property Q3DGraphsWidgetItem::cameraYRotation
*
* \brief The Y-rotation angle of the camera around the target point in degrees.
*/
float Q3DGraphsWidgetItem::cameraYRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->cameraYRotation();
}
void Q3DGraphsWidgetItem::setCameraYRotation(float rotation)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setCameraYRotation(rotation);
}
/*!
* \property Q3DGraphsWidgetItem::minCameraXRotation
*
* \brief The minimum X-rotation angle of the camera around the target point in degrees.
* The default value is \c{-180.0}
*/
float Q3DGraphsWidgetItem::minCameraXRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->minCameraXRotation();
}
void Q3DGraphsWidgetItem::setMinCameraXRotation(float rotation)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMinCameraXRotation(rotation);
}
/*!
* \property Q3DGraphsWidgetItem::maxCameraXRotation
*
* \brief The maximum X-rotation angle of the camera around the target point in degrees.
* The default value is \c{180.0}
*/
float Q3DGraphsWidgetItem::maxCameraXRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->maxCameraXRotation();
}
void Q3DGraphsWidgetItem::setMaxCameraXRotation(float rotation)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMaxCameraXRotation(rotation);
}
/*!
* \property Q3DGraphsWidgetItem::minCameraYRotation
*
* \brief The minimum Y-rotation angle of the camera around the target point in degrees.
* The default value is \c{0.0}
*/
float Q3DGraphsWidgetItem::minCameraYRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->minCameraYRotation();
}
void Q3DGraphsWidgetItem::setMinCameraYRotation(float rotation)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMinCameraYRotation(rotation);
}
/*!
* \property Q3DGraphsWidgetItem::maxCameraYRotation
*
* \brief The maximum Y-rotation angle of the camera around the target point in degrees.
* The default value is \c{90.0}
*/
float Q3DGraphsWidgetItem::maxCameraYRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->maxCameraYRotation();
}
void Q3DGraphsWidgetItem::setMaxCameraYRotation(float rotation)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMaxCameraYRotation(rotation);
}
/*!
* \property Q3DGraphsWidgetItem::zoomAtTargetEnabled
*
* \brief Whether zooming should change the camera target so that the zoomed point
* of the graph stays at the same location after the zoom.
*
* Defaults to \c{true}.
*/
bool Q3DGraphsWidgetItem::isZoomAtTargetEnabled() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->zoomAtTargetEnabled();
}
void Q3DGraphsWidgetItem::setZoomAtTargetEnabled(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setZoomAtTargetEnabled(enable);
}
/*!
* \property Q3DGraphsWidgetItem::zoomEnabled
*
* \brief Whether this input handler allows graph zooming.
*
* Defaults to \c{true}.
*/
bool Q3DGraphsWidgetItem::isZoomEnabled() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->zoomEnabled();
}
void Q3DGraphsWidgetItem::setZoomEnabled(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setZoomEnabled(enable);
}
/*!
* \property Q3DGraphsWidgetItem::ambientLightStrength
*
* \brief The ambient light strength for the whole graph.
*
* This value determines how evenly and brightly the colors are shown throughout
* the graph regardless of the light position.
*
* The value must be between \c 0.0f and \c 1.0f.
*/
float Q3DGraphsWidgetItem::ambientLightStrength() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->ambientLightStrength();
}
void Q3DGraphsWidgetItem::setAmbientLightStrength(float newAmbientLightStrength)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setAmbientLightStrength(newAmbientLightStrength);
}
/*!
* \property Q3DGraphsWidgetItem::lightStrength
*
* \brief The specular light strength for the whole graph.
*
* The value must be between \c 0.0f and \c 10.0f.
*
* This value affects the light specified in Q3DScene.
*/
float Q3DGraphsWidgetItem::lightStrength() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->lightStrength();
}
void Q3DGraphsWidgetItem::setLightStrength(float newLightStrength)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setLightStrength(newLightStrength);
}
/*!
* \property Q3DGraphsWidgetItem::shadowStrength
*
* \brief The shadow strength for the whole graph.
*
* The higher the number, the darker the shadows will be. The value must be
* between \c 0.0 and \c 100.0.
*
* This value affects the light specified in Q3DScene.
*/
float Q3DGraphsWidgetItem::shadowStrength() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->shadowStrength();
}
void Q3DGraphsWidgetItem::setShadowStrength(float newShadowStrength)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setShadowStrength(newShadowStrength);
}
/*!
* \property Q3DGraphsWidgetItem::lightColor
*
* \brief The color for the ambient and specular light.
*
* This value affects the light specified in Q3DScene.
*/
QColor Q3DGraphsWidgetItem::lightColor() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->lightColor();
}
void Q3DGraphsWidgetItem::setLightColor(QColor newLightColor)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setLightColor(newLightColor);
}
/*!
* \property Q3DGraphsWidgetItem::gridLineType
*
* \brief Whether the grid lines type is QtGraphs3D::GridLineType::Shader or
* QtGraphs3D::GridLineType::Geometry.
*
* This value affects all grid lines.
*
* \sa QtGraphs3D::GridLineType
*/
QtGraphs3D::GridLineType Q3DGraphsWidgetItem::gridLineType() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->gridLineType();
}
void Q3DGraphsWidgetItem::setGridLineType(const QtGraphs3D::GridLineType &gridLineType)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setGridLineType(gridLineType);
}
/*!
* Sets the given \a widget instance to be used as the \l QQuickWidget for the widget item.
* The graph is set as the content of the QQuickWidget.
*
* Graphs can only be rendered in widget applications using QQuickWidgets.
*
* Usage example:
* \code
* QQuickWidget quickwidget;
* Q3DBarsWidgetItem graph;
* graph.setWidget(&quickwidget);
* \endcode
*/
void Q3DGraphsWidgetItem::setWidget(QQuickWidget *widget)
{
Q_D(Q3DGraphsWidgetItem);
d->m_widget = widget;
if (d->m_widget != nullptr) {
d->m_widget->installEventFilter(this);
d->createGraph();
}
}
/*!
* Returns a pointer to the \l QQuickWidget instance that has been set for the widget item.
*/
QQuickWidget *Q3DGraphsWidgetItem::widget() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_widget;
}
/*!
* \property Q3DGraphsWidgetItem::selectionEnabled
*
* \brief Whether this input handler allows selection from the graph.
*
* Defaults to \c{true}.
*/
bool Q3DGraphsWidgetItem::isSelectionEnabled() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->selectionEnabled();
}
void Q3DGraphsWidgetItem::setSelectionEnabled(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setSelectionEnabled(enable);
}
/*!
* \property Q3DGraphsWidgetItem::rotationEnabled
*
* \brief Whether this input handler allows graph rotation.
*
* Defaults to \c{true}.
*/
bool Q3DGraphsWidgetItem::isRotationEnabled() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->rotationEnabled();
}
void Q3DGraphsWidgetItem::setRotationEnabled(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setRotationEnabled(enable);
}
/*!
* \property Q3DGraphsWidgetItem::panEnabled
* \since 6.12
*
* \brief Whether this input handler allows graph panning.
*
* Defaults to \c{true}.
*
* \sa dragMode, setPanButton()
*/
bool Q3DGraphsWidgetItem::isPanEnabled() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->panEnabled();
}
void Q3DGraphsWidgetItem::setPanEnabled(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setPanEnabled(enable);
}
/*!
* \property Q3DGraphsWidgetItem::dragMode
* \since 6.12
*
* \brief Determines how drag events on the graph are interpreted, one of
* QtGraphs3D::DragMode enum values.
*
* Defaults to \c{QtGraphs3D::DragMode::Rotate}.
*
* \sa panEnabled
*/
QtGraphs3D::DragMode Q3DGraphsWidgetItem::dragMode() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->dragMode();
}
void Q3DGraphsWidgetItem::setDragMode(QtGraphs3D::DragMode newDragMode)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setDragMode(newDragMode);
}
void Q3DGraphsWidgetItem::setDefaultInputHandler()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setDefaultInputHandler();
}
void Q3DGraphsWidgetItem::unsetDefaultInputHandler()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->unsetDefaultInputHandler();
}
void Q3DGraphsWidgetItem::unsetDefaultTapHandler()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->unsetDefaultTapHandler();
}
void Q3DGraphsWidgetItem::unsetDefaultDragHandler()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->unsetDefaultDragHandler();
}
void Q3DGraphsWidgetItem::unsetDefaultWheelHandler()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->unsetDefaultWheelHandler();
}
void Q3DGraphsWidgetItem::unsetDefaultPinchHandler()
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->unsetDefaultPinchHandler();
}
void Q3DGraphsWidgetItem::setDragButton(Qt::MouseButtons button)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setDragButton(button);
}
/*!
* \fn Q3DGraphsWidgetItem::setPanButton(Qt::MouseButtons button)
* \since 6.12
*
* Sets the mouse \a button used to trigger panning in 3D graphs.
*
* \sa panEnabled
*/
void Q3DGraphsWidgetItem::setPanButton(Qt::MouseButtons button)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setPanButton(button);
}
/*!
* \property Q3DGraphsWidgetItem::cameraZoomLevel
*
* \brief The camera zoom level in percentage.
*
* The default value of \c{100.0f} means there is no zoom in or out set in the
* camera. The value is limited by the minCameraZoomLevel and maxCameraZoomLevel
* properties.
*
* \sa minCameraZoomLevel, maxCameraZoomLevel
*/
float Q3DGraphsWidgetItem::cameraZoomLevel() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->cameraZoomLevel();
}
void Q3DGraphsWidgetItem::setCameraZoomLevel(float level)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setCameraZoomLevel(level);
d->m_graphsItem->update();
}
/*!
* \property Q3DGraphsWidgetItem::minCameraZoomLevel
*
* \brief The minimum allowed camera zoom level.
*
* If the minimum level is set to a new value that is higher than the existing
* maximum level, the maximum level is adjusted to the new minimum as well.
* If the current zoomLevel is outside the new bounds, it is adjusted as well.
* The minCameraZoomLevel cannot be set below \c{1.0f}.
* Defaults to \c{10.0f}.
*
* \sa cameraZoomLevel, maxCameraZoomLevel
*/
float Q3DGraphsWidgetItem::minCameraZoomLevel() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->minCameraZoomLevel();
}
void Q3DGraphsWidgetItem::setMinCameraZoomLevel(float level)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMinCameraZoomLevel(level);
}
/*!
* \property Q3DGraphsWidgetItem::maxCameraZoomLevel
*
* \brief The maximum allowed camera zoom level.
*
* If the maximum level is set to a new value that is lower than the existing
* minimum level, the minimum level is adjusted to the new maximum as well.
* If the current cameraZoomLevel is outside the new bounds, it is adjusted as
* well. Defaults to \c{500.0f}.
*
* \sa cameraZoomLevel, minCameraZoomLevel
*/
float Q3DGraphsWidgetItem::maxCameraZoomLevel() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->maxCameraZoomLevel();
}
void Q3DGraphsWidgetItem::setMaxCameraZoomLevel(float level)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMaxCameraZoomLevel(level);
}
/*!
* \property Q3DGraphsWidgetItem::cameraTargetPosition
*
* \brief The camera target position as a vector or vertex in the 3D space.
*
* Defaults to \c {QVector3D(0.0, 0.0, 0.0)}.
*
* Valid coordinate values are between \c{-1.0...1.0}, where the edge values
* indicate the edges of the corresponding axis range. Any values outside this
* range are clamped to the edge.
*/
QVector3D Q3DGraphsWidgetItem::cameraTargetPosition() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->cameraTargetPosition();
}
void Q3DGraphsWidgetItem::setCameraTargetPosition(QVector3D target)
{
Q_D(Q3DGraphsWidgetItem);
QVector3D newTarget = target;
if (newTarget.x() < -1.0f)
newTarget.setX(-1.0f);
else if (newTarget.x() > 1.0f)
newTarget.setX(1.0f);
if (newTarget.y() < -1.0f)
newTarget.setY(-1.0f);
else if (newTarget.y() > 1.0f)
newTarget.setY(1.0f);
if (newTarget.z() < -1.0f)
newTarget.setZ(-1.0f);
else if (newTarget.z() > 1.0f)
newTarget.setZ(1.0f);
if (d->m_graphsItem->cameraTargetPosition() != newTarget) {
if (d->m_graphsItem->cameraPreset() != QtGraphs3D::CameraPreset::NoPreset)
d->m_graphsItem->setCameraPreset(QtGraphs3D::CameraPreset::NoPreset);
d->m_graphsItem->setCameraTargetPosition(newTarget);
}
}
/*!
* \property Q3DGraphsWidgetItem::wrapCameraXRotation
*
* \brief The behavior of the minimum and maximum limits in the X-rotation.
*
* If set to \c true, the X-rotation of the camera is wrapped from minimum to
* maximum and from maximum to minimum. If set to \c false, the X-rotation of
* the camera is limited to the sector determined by the minimum and maximum
* values. Set to \c true by default.
*/
bool Q3DGraphsWidgetItem::wrapCameraXRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->wrapCameraXRotation();
}
void Q3DGraphsWidgetItem::setWrapCameraXRotation(bool wrap)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setWrapCameraXRotation(wrap);
}
/*!
* \property Q3DGraphsWidgetItem::wrapCameraYRotation
*
* \brief The behavior of the minimum and maximum limits in the Y-rotation.
*
* If \c true, the Y-rotation of the camera is wrapped from minimum to maximum
* and from maximum to minimum. If \c false, the Y-rotation of the camera is
* limited to the sector determined by the minimum and maximum values.
* Set to \c true by default.
*/
bool Q3DGraphsWidgetItem::wrapCameraYRotation() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->wrapCameraYRotation();
}
void Q3DGraphsWidgetItem::setWrapCameraYRotation(bool wrap)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setWrapCameraYRotation(wrap);
}
/*!
* Utility function that sets the camera rotations and distance.\a horizontal
* and \a vertical define the camera rotations to be used. Optional \a zoom
* parameter can be given to set the zoom percentage of the camera within the
* bounds defined by minCameraZoomLevel and maxCameraZoomLevel properties.
*/
void Q3DGraphsWidgetItem::setCameraPosition(float horizontal, float vertical, float zoom)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setCameraPosition(horizontal, vertical, zoom);
}
/*!
* \property Q3DGraphsWidgetItem::msaaSamples
*
* \brief The number of used samples in MSAA.
*
* Sets the number of used MSAA samples to \a samples. The number of samples can
* be either 0, 2, 4, or 8.
*
*/
int Q3DGraphsWidgetItem::msaaSamples() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->msaaSamples();
}
void Q3DGraphsWidgetItem::setMsaaSamples(int samples)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMsaaSamples(samples);
}
/*!
* Performs picking using view coordinates from \a point
* on the elements of the graph, selecting the first item hit.
* Default input handling performs this upon receiving the onTapped event.
*
* \sa selectedElement
*/
void Q3DGraphsWidgetItem::doPicking(QPoint point)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->doPicking(point);
}
/*!
* Performs picking starting from \a origin and in \a direction
* on the elements of the graph, selecting the first item hit.
*
* \sa selectedElement
*/
void Q3DGraphsWidgetItem::doRayPicking(QVector3D origin, QVector3D direction)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->doRayPicking(origin, direction);
}
/*!
* \property Q3DGraphsWidgetItem::measureFps
*
* \brief Whether rendering is done continuously instead of on demand.
*
* If \c {true}, rendering is continuous and the value of the currentFps
* property is updated. Defaults to \c{false}.
*
* \sa currentFps
*/
void Q3DGraphsWidgetItem::setMeasureFps(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMeasureFps(enable);
if (enable) {
QObject::connect(d->m_graphsItem.get(),
&QQuickGraphsItem::currentFpsChanged,
this,
&Q3DGraphsWidgetItem::currentFpsChanged);
} else {
QObject::disconnect(d->m_graphsItem.get(),
&QQuickGraphsItem::currentFpsChanged,
this,
&Q3DGraphsWidgetItem::currentFpsChanged);
}
}
bool Q3DGraphsWidgetItem::measureFps() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->measureFps();
}
/*!
* \property Q3DGraphsWidgetItem::currentFps
*
* \brief The rendering results for the last second.
*
* The results are stored in this read-only property when FPS measuring is
* enabled. It takes at least a second before this value is updated after
* measuring is activated.
*
* \sa measureFps
*/
int Q3DGraphsWidgetItem::currentFps() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->currentFps();
}
/*!
* \property Q3DGraphsWidgetItem::orthoProjection
*
* \brief Whether orthographic projection is used for displaying the graph.
*
* Defaults to \c{false}.
* \note Shadows will be disabled when set to \c{true}.
*
* \sa QAbstract3DAxis::labelAutoAngle,
*/
void Q3DGraphsWidgetItem::setOrthoProjection(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setOrthoProjection(enable);
}
bool Q3DGraphsWidgetItem::isOrthoProjection() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->isOrthoProjection();
}
/*!
* \property Q3DGraphsWidgetItem::aspectRatio
*
* \brief The ratio of the graph scaling between the longest axis on the
* horizontal plane and the y-axis.
*
* Defaults to \c{2.0}.
*
* \note Has no effect on Q3DBarsWidgetItem.
*
* \sa horizontalAspectRatio
*/
void Q3DGraphsWidgetItem::setAspectRatio(qreal ratio)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setAspectRatio(ratio);
}
qreal Q3DGraphsWidgetItem::aspectRatio() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->aspectRatio();
}
/*!
* \property Q3DGraphsWidgetItem::optimizationHint
*
* \brief Specifies whether the default or legacy mode is used for rendering
* optimization.
*
* The default mode uses instanced rendering, and provides the full feature set
* at the best level of performance on most systems. The static mode optimizes
* graph rendering and is ideal for large non-changing data sets. It is slower
* with dynamic data changes and item rotations. Selection is not optimized, so
* using the static mode with massive data sets is not advisable. Static
* optimization works only on scatter graphs. Legacy mode renders all items in
* th graph individually, without instancing. It should be used only if default
* mode does not work, i.e. if the target system does not support instancing.
* Defaults to \l{QtGraphs3D::OptimizationHint::Default}.
*
* \note On some environments, large graphs using static optimization may not
* render, because all of the items are rendered using a single draw call, and
* different graphics drivers support different maximum vertice counts per call.
* This is mostly an issue on 32bit and OpenGL ES2 platforms.
* To work around this issue, choose an item mesh with a low vertex count or use
* the point mesh.
*
* \sa QAbstract3DSeries::mesh
*/
void Q3DGraphsWidgetItem::setOptimizationHint(QtGraphs3D::OptimizationHint hint)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setOptimizationHint(hint);
}
QtGraphs3D::OptimizationHint Q3DGraphsWidgetItem::optimizationHint() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->optimizationHint();
}
/*!
* \property Q3DGraphsWidgetItem::polar
*
* \brief Whether horizontal axes are changed into polar axes.
*
* If \c {true}, the x-axis becomes the angular axis and the z-axis becomes the
* radial axis.
* Polar mode is not available for bar graphs.
*
* Defaults to \c{false}.
*
* \sa orthoProjection, radialLabelOffset
*/
void Q3DGraphsWidgetItem::setPolar(bool enable)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setPolar(enable);
}
bool Q3DGraphsWidgetItem::isPolar() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->isPolar();
}
/*!
* \property Q3DGraphsWidgetItem::labelMargin
*
* \brief This property specifies the margin for the placement of the axis labels.
*
* Negative values place the labels inside the plot-area while positive values
* place them outside the plot-area. Label automatic rotation is disabled when
* the value is negative. Defaults to \c 0.1
*
* \sa QAbstract3DAxis::labelAutoAngle
*
*/
void Q3DGraphsWidgetItem::setLabelMargin(float margin)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setLabelMargin(margin);
}
float Q3DGraphsWidgetItem::labelMargin() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->labelMargin();
}
/*!
* \property Q3DGraphsWidgetItem::radialLabelOffset
*
* \brief The normalized horizontal offset for the axis labels of the radial
* polar axis.
*
* The value \c 0.0 indicates that the labels should be drawn next to the
* 0-angle angular axis grid line. The value \c 1.0 indicates that the labels
* are drawn in their usual place at the edge of the graph background. Defaults
* to \c 1.0.
*
* This property is ignored if the \l polar property value is \c{false}.
*
* \sa polar
*/
void Q3DGraphsWidgetItem::setRadialLabelOffset(float offset)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setRadialLabelOffset(offset);
}
float Q3DGraphsWidgetItem::radialLabelOffset() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->radialLabelOffset();
}
/*!
* \property Q3DGraphsWidgetItem::horizontalAspectRatio
*
* \brief The ratio of the graph scaling between the x-axis and z-axis.
*
* The value of \c 0.0 indicates automatic scaling according to axis ranges.
* Defaults to \c{0.0}.
*
* Has no effect on Q3DBarsWidgetItem, which handles scaling on the horizontal plane via
* the \l{Q3DBarsWidgetItem::barThickness}{barThickness} and
* \l{Q3DBarsWidgetItem::barSpacing}{barSpacing} properties. Polar graphs also ignore this
* property.
*
* \sa aspectRatio, polar, Q3DBarsWidgetItem::barThickness, Q3DBarsWidgetItem::barSpacing
*/
void Q3DGraphsWidgetItem::setHorizontalAspectRatio(qreal ratio)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setHorizontalAspectRatio(ratio);
}
qreal Q3DGraphsWidgetItem::horizontalAspectRatio() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->horizontalAspectRatio();
}
/*!
* \property Q3DGraphsWidgetItem::locale
*
* \brief The locale used for formatting various numeric labels.
*
* Defaults to the \c{"C"} locale.
*
* \sa QValue3DAxis::labelFormat
*/
void Q3DGraphsWidgetItem::setLocale(const QLocale &locale)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setLocale(locale);
}
QLocale Q3DGraphsWidgetItem::locale() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->locale();
}
/*!
* \property Q3DGraphsWidgetItem::queriedGraphPosition
* \readonly
*
* \brief The latest queried graph position values along each axis.
*
* This read-only property contains the results from
* Q3DScene::graphPositionQuery. The values are normalized to the range \c{[-1,
* 1]}. If the queried position was outside the graph bounds, the values will
* not reflect the real position, but will instead indicate an undefined
* position outside the range \c{[-1, 1]}. The value will be undefined until a
* query is made.
*
* There is no single correct 3D coordinate to match a particular screen
* position, so to be consistent, the queries are always done against the inner
* sides of an invisible box surrounding the graph.
*
* \note Bar graphs only allow querying graph position at the graph floor level,
* so the y-value is always zero for bar graphs and the valid queries can be
* only made at screen positions that contain the floor of the graph.
*
* \sa Q3DScene::graphPositionQuery
*/
QVector3D Q3DGraphsWidgetItem::queriedGraphPosition() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->queriedGraphPosition();
}
/*!
* \property Q3DGraphsWidgetItem::margin
*
* \brief The absolute value used for the space left between the edge of the
* plottable graph area and the edge of the graph background.
*
* If the margin value is negative, the margins are determined automatically and
* can vary according to the size of the items in the series and the type of the
* graph. The value is interpreted as a fraction of the y-axis range if the
* graph aspect ratios have not been changed from the default values. Defaults
* to \c{-1.0}.
*
* \note Setting a smaller margin for a scatter graph than the automatically
* determined margin can cause the scatter items at the edges of the graph to
* overlap with the graph background.
*
* \note On scatter and surface graphs, if the margin is small in comparison to
* the axis label size, the positions of the edge labels of the axes are
* adjusted to avoid overlap with the edge labels of the neighboring axes.
*/
void Q3DGraphsWidgetItem::setMargin(qreal margin)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setMargin(margin);
}
qreal Q3DGraphsWidgetItem::margin() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->margin();
}
/*!
* \property Q3DGraphsWidgetItem::cutoffMargin
* \since 6.11
*
* \brief The value used for the space between the axis limits
* and the position at which graph elements are culled.
*
* \note Does not affect bar graphs.
*/
void Q3DGraphsWidgetItem::setCutoffMargin(qreal margin)
{
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->setCutoffMargin(margin);
}
qreal Q3DGraphsWidgetItem::cutoffMargin() const
{
Q_D(const Q3DGraphsWidgetItem);
return d->m_graphsItem->cutoffMargin();
}
/*!
* \internal
*/
bool Q3DGraphsWidgetItem::event(QEvent *event)
{
switch (event->type()) {
case QEvent::TouchBegin:
case QEvent::TouchCancel:
case QEvent::TouchUpdate:
case QEvent::TouchEnd: {
Q_D(Q3DGraphsWidgetItem);
d->m_graphsItem->touchEvent(static_cast<QTouchEvent *>(event));
}
return true;
default:
return QObject::event(event);
}
}
bool Q3DGraphsWidgetItem::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::Resize) {
Q_D(Q3DGraphsWidgetItem);
auto ev = static_cast<QResizeEvent *>(event);
if (d->m_graphsItem) {
Q3DScene *scene = (Q3DScene *) d->m_graphsItem->scene();
scene->d_func()->setWindowSize(QSize(ev->size().width(), ev->size().height()));
d->m_graphsItem->resizeViewports(ev->size());
if (d->m_graphsItem->sliceView() && d->m_graphsItem->sliceView()->isVisible())
d->m_graphsItem->minimizeMainGraph();
d->m_graphsItem->updateSubViews();
}
return false;
}
return QObject::eventFilter(obj, event);
}
/*!
* \internal
*/
void Q3DGraphsWidgetItemPrivate::onWheel(QQuickWheelEvent *event)
{
Q_Q(Q3DGraphsWidgetItem);
QWheelEvent *ev = new QWheelEvent(QPointF(event->x(), event->y()),
QPointF(event->x(), event->y()),
event->pixelDelta(),
event->angleDelta(),
static_cast<Qt::MouseButton>(event->buttons()),
static_cast<Qt::KeyboardModifier>(event->modifiers()),
event->phase(),
event->inverted(),
Qt::MouseEventSynthesizedBySystem,
event->pointingDevice());
emit q->wheel(ev);
}
void Q3DGraphsWidgetItemPrivate::createGraph()
{
Q_Q(Q3DGraphsWidgetItem);
if (m_widget == nullptr)
return;
m_widget->setResizeMode(QQuickWidget::SizeRootObjectToView);
#ifdef Q_OS_DARWIN
// Take care of widget users (or CI) wanting to use OpenGL backend on macOS
if (QQuickWindow::graphicsApi() == QSGRendererInterface::OpenGL)
QSurfaceFormat::setDefaultFormat(QQuick3D::idealSurfaceFormat(4));
#endif
const QString qmlData = QLatin1StringView(R"QML(
import QtQuick;
import QtGraphs;
%1
{
anchors.fill: parent;
}
)QML")
.arg(m_graphType);
QQmlComponent *component = new QQmlComponent(m_widget->engine(), q);
component->setData(qmlData.toUtf8(), QUrl());
m_graphsItem.reset(qobject_cast<QQuickGraphsItem *>(component->create()));
if (!m_graphsItem) {
qWarning("Failed to create %ls: %ls",
qUtf16Printable(m_graphType),
qUtf16Printable(component->errorString().trimmed()));
return;
}
m_widget->setContent(component->url(), component, m_graphsItem.get());
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::selectedElementChanged,
q,
&Q3DGraphsWidgetItem::selectedElementChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::msaaSamplesChanged,
q,
&Q3DGraphsWidgetItem::msaaSamplesChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::tapped,
q,
&Q3DGraphsWidgetItem::tapped);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::doubleTapped,
q,
&Q3DGraphsWidgetItem::doubleTapped);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::longPressed,
q,
&Q3DGraphsWidgetItem::longPressed);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::dragged,
q,
&Q3DGraphsWidgetItem::dragged);
QObjectPrivate::connect(m_graphsItem.get(),
&QQuickGraphsItem::wheel,
this,
&Q3DGraphsWidgetItemPrivate::onWheel);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::pinch,
q,
&Q3DGraphsWidgetItem::pinch);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::mouseMove,
q,
&Q3DGraphsWidgetItem::mouseMove);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::zoomEnabledChanged,
q,
&Q3DGraphsWidgetItem::zoomEnabledChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::zoomAtTargetEnabledChanged,
q,
&Q3DGraphsWidgetItem::zoomAtTargetEnabledChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::rotationEnabledChanged,
q,
&Q3DGraphsWidgetItem::rotationEnabledChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::selectionEnabledChanged,
q,
&Q3DGraphsWidgetItem::selectionEnabledChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::queriedGraphPositionChanged,
q,
&Q3DGraphsWidgetItem::queriedGraphPositionChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::ambientLightStrengthChanged,
q,
&Q3DGraphsWidgetItem::ambientLightStrengthChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::lightStrengthChanged,
q,
&Q3DGraphsWidgetItem::lightStrengthChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::shadowStrengthChanged,
q,
&Q3DGraphsWidgetItem::shadowStrengthChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::lightColorChanged,
q,
&Q3DGraphsWidgetItem::lightColorChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::gridLineTypeChanged,
q,
&Q3DGraphsWidgetItem::gridLineTypeChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::activeThemeChanged,
q,
&Q3DGraphsWidgetItem::activeThemeChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::transparencyTechniqueChanged,
q,
&Q3DGraphsWidgetItem::transparencyTechniqueChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::selectionModeChanged,
q,
&Q3DGraphsWidgetItem::selectionModeChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::shadowQualityChanged,
q,
&Q3DGraphsWidgetItem::shadowQualityChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::cameraPresetChanged,
q,
&Q3DGraphsWidgetItem::cameraPresetChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::cameraXRotationChanged,
q,
&Q3DGraphsWidgetItem::cameraXRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::cameraYRotationChanged,
q,
&Q3DGraphsWidgetItem::cameraYRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::minCameraXRotationChanged,
q,
&Q3DGraphsWidgetItem::minCameraXRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::maxCameraXRotationChanged,
q,
&Q3DGraphsWidgetItem::maxCameraXRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::minCameraYRotationChanged,
q,
&Q3DGraphsWidgetItem::minCameraYRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::maxCameraYRotationChanged,
q,
&Q3DGraphsWidgetItem::maxCameraYRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::cameraZoomLevelChanged,
q,
&Q3DGraphsWidgetItem::cameraZoomLevelChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::minCameraZoomLevelChanged,
q,
&Q3DGraphsWidgetItem::minCameraZoomLevelChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::maxCameraZoomLevelChanged,
q,
&Q3DGraphsWidgetItem::maxCameraZoomLevelChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::wrapCameraXRotationChanged,
q,
&Q3DGraphsWidgetItem::wrapCameraXRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::wrapCameraYRotationChanged,
q,
&Q3DGraphsWidgetItem::wrapCameraYRotationChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::measureFpsChanged,
q,
&Q3DGraphsWidgetItem::measureFpsChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::orthoProjectionChanged,
q,
&Q3DGraphsWidgetItem::orthoProjectionChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::aspectRatioChanged,
q,
&Q3DGraphsWidgetItem::aspectRatioChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::optimizationHintChanged,
q,
&Q3DGraphsWidgetItem::optimizationHintChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::polarChanged,
q,
&Q3DGraphsWidgetItem::polarChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::labelMarginChanged,
q,
&Q3DGraphsWidgetItem::labelMarginChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::radialLabelOffsetChanged,
q,
&Q3DGraphsWidgetItem::radialLabelOffsetChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::horizontalAspectRatioChanged,
q,
&Q3DGraphsWidgetItem::horizontalAspectRatioChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::localeChanged,
q,
&Q3DGraphsWidgetItem::localeChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::marginChanged,
q,
&Q3DGraphsWidgetItem::marginChanged);
QObject::connect(m_graphsItem.get(),
&QQuickGraphsItem::cutoffMarginChanged,
q,
&Q3DGraphsWidgetItem::cutoffMarginChanged);
m_widget->installEventFilter(q);
}
QT_END_NAMESPACE