qquickgraphsbars.cpp

++ // 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 "graphs3d/utils/qgraphs3dlogging_p.h"

++ #include "q3dscene.h"

++ #include "qbar3dseries.h"

++ #include "qbar3dseries_p.h"

++ #include "qbardataproxy_p.h"

++ #include "qcategory3daxis_p.h"

++ #include "qgraphsinputhandler_p.h"

++ #include "qgraphstheme.h"

++ #include "qquickgraphsbars_p.h"

++ #include "qquickgraphstexturedata_p.h"

++ #include "qvalue3daxis_p.h"

++ #include "qgraphs3dlogging_p.h"

++

++ #include <QColor>

++ #include <QtQuick3D/private/qquick3dcustommaterial_p.h>

++ #include <QtQuick3D/private/qquick3dprincipledmaterial_p.h>

++ #include <QtQuick3D/private/qquick3drepeater_p.h>

++ #include <QtQuick/qquickitemgrabresult.h>

++

++ #include <QtGui/qquaternion.h>

++

++ QT_BEGIN_NAMESPACE

++

++ #include <qtgraphs_tracepoints_p.h>

++

++ Q_TRACE_PREFIX(qtgraphs,

++                    "QT_BEGIN_NAMESPACE" \

++                    "#include <graphs3d/utils/qgraphs3dnamespace.h>" \

++                    "class qquickgraphsbars;" \

++                    "QT_END_NAMESPACE"

++                )

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsSynch_entry_beforeGraphsItem);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsSynch_exit_beforeGraphsItem);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsSynch_entry_afterGraphsItem);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsSynch_exit_afterGraphsItem);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBarsUpdateGraph_entry);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBarsUpdateGraph_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBars_entry, int seriesCount);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBars_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBarsLegacy_entry);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBarsLegacy_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBarsDefault_entry);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsGenerateBarsDefault_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsUpdateBarPositionsLegacy_entry);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsUpdateBarPositionsLegacy_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsDoPicking_entry, float posX, float posY);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsDoPicking_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsDoRayPicking_entry, float originX, float originY,

++               float originZ, float directionX, float directionY, float directionZ);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsDoRayPicking_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsCreateSliceView_entry);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsCreateSliceView_exit);

++

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsCreateOffscreenSliceView_entry, int requestedIndex, int sliceType);

++ Q_TRACE_POINT(qtgraphs, QGraphs3DBarsCreateOffscreenSliceView_exit);

++

++ /*!

++  * \qmltype Bars3D

++  * \inherits GraphsItem3D

++  * \inqmlmodule QtGraphs

++  * \ingroup graphs_qml_3D

++  * \brief 3D bar graph.

++  *

++  * This type enables developers to render bar graphs in 3D with Qt Quick.

++  *

++  * You will need to import Qt Graphs module to use this type:

++  *

++  * \snippet doc_src_qmlgraphs.cpp 0

++  *

++  * After that you can use Bars3D in your qml files:

++  *

++  * \snippet doc_src_qmlgraphs.cpp 1

++  *

++  * See \l{Simple Bar Graph} for more thorough usage example.

++  *

++  * \sa Bar3DSeries, ItemModelBarDataProxy, Scatter3D, Surface3D, {Qt Graphs C++ Classes for 3D}

++  */

++

++ /*!

++  * \qmlproperty Category3DAxis Bars3D::rowAxis

++  * The active row axis.

++  *

++  * If an axis is not given, a temporary default axis with no labels is created.

++  * This temporary axis is destroyed if another axis is explicitly set to the

++  * same orientation.

++  */

++

++ /*!

++  * \qmlproperty ValueAxis3D Bars3D::valueAxis

++  * The active value axis.

++  *

++  * If an axis is not given, a temporary default axis with no labels and an

++  * automatically adjusting range is created.

++  * This temporary axis is destroyed if another axis is explicitly set to the

++  * same orientation.

++  */

++

++ /*!

++  * \qmlproperty Category3DAxis Bars3D::columnAxis

++  * The active column axis.

++  *

++  * If an axis is not given, a temporary default axis with no labels is created.

++  * This temporary axis is destroyed if another axis is explicitly set to the

++  * same orientation.

++  */

++

++ /*!

++  * \qmlproperty bool Bars3D::multiSeriesUniform

++  * Defines whether bars are to be scaled with proportions set to a single series bar even

++  * if there are multiple series displayed. If set to \c {true}, \l{barSpacing}{bar spacing} will

++  * be correctly applied only to the X-axis. Preset to \c false by default.

++  */

++

++ /*!

++  * \qmlproperty real Bars3D::barThickness

++  * The bar thickness ratio between the X and Z dimensions. The value \c 1.0

++  * means that the bars are as wide as they are deep, whereas \c 0.5

++  * makes them twice as deep as they are wide.

++  */

++

++ /*!

++  * \qmlproperty size Bars3D::barSpacing

++  * Bar spacing in X and Z dimensions.

++  *

++  * Preset to \c {(1.0, 1.0)} by default. Spacing is affected by the

++  * barSpacingRelative property.

++  */

++

++ /*!

++  * \qmlproperty bool Bars3D::barSpacingRelative

++  * Whether spacing is absolute or relative to bar thickness.

++  *

++  * If \c true, the value of \c 0.0 means that the bars are placed

++  * side-to-side, \c 1.0 means that a space as wide as the thickness of one bar

++  * is left between the bars, and so on. Preset to \c true.

++  */

++

++ /*!

++  * \qmlproperty size Bars3D::barSeriesMargin

++  *

++  * Margin between series columns in X and Z dimensions. Preset to \c {(0.0, 0.0)} by default.

++  * Sensible values are on the range [0,1).

++  */

++

++ /*!

++  * \qmlproperty Bar3DSeries Bars3D::selectedSeries

++  * \readonly

++  *

++  * The selected series or \c null. If \l {GraphsItem3D::selectionMode}{selectionMode} has

++  * the \c SelectionMultiSeries flag set, this property holds the series that

++  * owns the selected bar.

++  */

++

++ /*!

++  * \qmlproperty list<Bar3DSeries> Bars3D::seriesList

++  * \qmldefault

++  * The series of the graph.

++  * By default, this property contains an empty list.

++  * To set the series, either use the addSeries() function or define them as children of the graph.

++  */

++

++ /*!

++  * \qmlproperty Bar3DSeries Bars3D::primarySeries

++  * The primary series of the graph. It

++  * is used to determine the row and column axis labels when the labels are not explicitly

++  * set to the axes.

++  *

++  * If the specified series is not yet added to the graph, setting it as the

++  * primary series will also implicitly add it to the graph.

++  *

++  * If the primary series itself is removed from the graph, this property

++  * resets to default.

++  *

++  * If the series is null, this property resets to default.

++  * Defaults to the first added series or zero if no series are added to the graph.

++  */

++

++ /*!

++  * \qmlproperty real Bars3D::floorLevel

++  *

++  * The floor level for the bar graph in Y-axis data coordinates.

++  *

++  * The actual floor level will be restricted by the Y-axis minimum and maximum

++  * values.

++  * Defaults to zero.

++  */

++

++ /*!

++  * \qmlmethod void Bars3D::addSeries(Bar3DSeries series)

++  * Adds the \a series to the graph. A graph can contain multiple series, but only one set of axes,

++  * so the rows and columns of all series must match for the visualized data to be meaningful.

++  * If the graph has multiple visible series, only the first one added will

++  * generate the row or column labels on the axes in cases where the labels are not explicitly set

++  * to the axes. If the newly added series has specified a selected bar, it will be highlighted and

++  * any existing selection will be cleared. Only one added series can have an active selection.

++  * \sa GraphsItem3D::hasSeries()

++  */

++

++ /*!

++  * \qmlmethod void Bars3D::removeSeries(Bar3DSeries series)

++  * Remove the \a series from the graph.

++  * \sa GraphsItem3D::hasSeries()

++  */

++

++ /*!

++  * \qmlmethod void Bars3D::insertSeries(int index, Bar3DSeries series)

++  * Inserts the \a series into the position \a index in the series list.

++  * If the \a series has already been added to the list, it is moved to the

++  * new \a index.

++  * \note When moving a series to a new \a index that is after its old index,

++  * the new position in list is calculated as if the series was still in its old

++  * index, so the final index is actually the \a index decremented by one.

++  * \sa GraphsItem3D::hasSeries()

++  */

++

++ /*!

++  * \qmlmethod void Bars3D::renderSliceToImage(int requestedIndex, QtGraphs3D::SliceCaptureType sliceType, QUrl filePath)

++  * \since 6.10

++  *

++  * Exports a 2d slice from series at \a requestedIndex and saves the result to an image

++  * at a specified \a filePath.

++  * The exported slice includes bars of row or column, which is defined by

++  * \a sliceType.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::multiSeriesUniformChanged(bool uniform)

++  *

++  * This signal is emitted when multiSeriesUniform changes to \a uniform.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::barThicknessChanged(real thicknessRatio)

++  *

++  * This signal is emitted when barThickness changes to \a thicknessRatio.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::barSpacingChanged(size spacing)

++  *

++  * This signal is emitted when barSpacing changes to \a spacing.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::barSpacingRelativeChanged(bool relative)

++  *

++  * This signal is emitted when barSpacingRelative changes to \a relative.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::barSeriesMarginChanged(size margin)

++  *

++  * This signal is emitted when barSeriesMargin changes to \a margin.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::rowAxisChanged(Category3DAxis axis)

++  *

++  * This signal is emitted when rowAxis changes to \a axis.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::columnAxisChanged(Category3DAxis axis)

++  *

++  * This signal is emitted when columnAxis changes to \a axis.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::valueAxisChanged(ValueAxis3D axis)

++  *

++  * This signal is emitted when valueAxis changes to \a axis.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::primarySeriesChanged(Bar3DSeries series)

++  *

++  * This signal is emitted when primarySeries changes to \a series.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::selectedSeriesChanged(Bar3DSeries series)

++  *

++  * This signal is emitted when selectedSeries changes to \a series.

++  */

++

++ /*!

++  * \qmlsignal Bars3D::floorLevelChanged(real level)

++  *

++  * This signal is emitted when floorLevel changes to \a level.

++  */

++

++ QQuickGraphsBars::QQuickGraphsBars(QQuickItem *parent)

++     : QQuickGraphsItem(parent)

++ {

++     m_graphType = QAbstract3DSeries::SeriesType::Bar;

++     setAxisX(0);

++     setAxisY(0);

++     setAxisZ(0);

++     setAcceptedMouseButtons(Qt::AllButtons);

++     setFlags(ItemHasContents);

++     clearSelection();

++ }

++

++ QQuickGraphsBars::~QQuickGraphsBars()

++ {

++     removeBarModels();

++     removeSlicedBarModels();

++     if (m_grabresult)

++         delete m_grabresult;

++ }

++

++ QCategory3DAxis *QQuickGraphsBars::rowAxis() const

++ {

++     return static_cast<QCategory3DAxis *>(axisZ());

++ }

++

++ void QQuickGraphsBars::setRowAxis(QCategory3DAxis *axis)

++ {

++     QQuickGraphsItem::setAxisZ(axis);

++ }

++

++ QValue3DAxis *QQuickGraphsBars::valueAxis() const

++ {

++     return static_cast<QValue3DAxis *>(axisY());

++ }

++

++ void QQuickGraphsBars::setValueAxis(QValue3DAxis *axis)

++ {

++     QQuickGraphsItem::setAxisY(axis);

++ }

++

++ QCategory3DAxis *QQuickGraphsBars::columnAxis() const

++ {

++     return static_cast<QCategory3DAxis *>(axisX());

++ }

++

++ void QQuickGraphsBars::setColumnAxis(QCategory3DAxis *axis)

++ {

++     QQuickGraphsItem::setAxisX(axis);

++ }

++

++ void QQuickGraphsBars::setMultiSeriesScaling(bool uniform)

++ {

++     m_isMultiSeriesUniform = uniform;

++

++     m_changeTracker.multiSeriesScalingChanged = true;

++     emitNeedRender();

++ }

++

++ bool QQuickGraphsBars::multiSeriesScaling() const

++ {

++     return m_isMultiSeriesUniform;

++ }

++

++ void QQuickGraphsBars::setMultiSeriesUniform(bool uniform)

++ {

++     if (uniform == isMultiSeriesUniform()) {

++         qCDebug(lcProperties3D) << __FUNCTION__

++             << "value is already set to:" << uniform;

++         return;

++     }

++     setMultiSeriesScaling(uniform);

++     emit multiSeriesUniformChanged(uniform);

++ }

++

++ bool QQuickGraphsBars::isMultiSeriesUniform() const

++ {

++     return multiSeriesScaling();

++ }

++

++ void QQuickGraphsBars::setBarSpecs(float thicknessRatio, QSizeF spacing, bool relative)

++ {

++     m_barThicknessRatio = thicknessRatio;

++     m_barSpacing = spacing;

++     m_isBarSpecRelative = relative;

++

++     m_changeTracker.barSpecsChanged = true;

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::setBarThickness(float thicknessRatio)

++ {

++     if (thicknessRatio == barThickness() || thicknessRatio <= 0.f) {

++         qCDebug(lcProperties3D, "%s value is already set to: %.1f",

++                 qUtf8Printable(QLatin1String(__FUNCTION__)), thicknessRatio);

++         return;

++     }

++     setBarSpecs(thicknessRatio, barSpacing(), isBarSpacingRelative());

++     emit barThicknessChanged(thicknessRatio);

++ }

++

++ float QQuickGraphsBars::barThickness() const

++ {

++     return m_barThicknessRatio;

++ }

++

++ void QQuickGraphsBars::setBarSpacing(QSizeF spacing)

++ {

++     if (spacing == barSpacing()) {

++         qCDebug(lcProperties3D) << __FUNCTION__

++                 << "value is already set to:" << spacing;

++         return;

++     }

++     setBarSpecs(barThickness(), spacing, isBarSpacingRelative());

++     emit barSpacingChanged(spacing);

++ }

++

++ QSizeF QQuickGraphsBars::barSpacing() const

++ {

++     return m_barSpacing;

++ }

++

++ void QQuickGraphsBars::setBarSpacingRelative(bool relative)

++ {

++     if (relative == isBarSpacingRelative()) {

++         qCDebug(lcProperties3D) << __FUNCTION__

++             << "value is already set to:" << relative;

++         return;

++     }

++     setBarSpecs(barThickness(), barSpacing(), relative);

++     emit barSpacingRelativeChanged(relative);

++ }

++

++ bool QQuickGraphsBars::isBarSpacingRelative() const

++ {

++     return m_isBarSpecRelative;

++ }

++

++ void QQuickGraphsBars::setBarSeriesMargin(QSizeF margin)

++ {

++     if (margin == barSeriesMargin()) {

++         qCDebug(lcProperties3D) << __FUNCTION__

++             << "value is already set to:" << margin;

++         return;

++     }

++     m_barSeriesMargin = margin;

++     m_changeTracker.barSeriesMarginChanged = true;

++     emitNeedRender();

++     emit barSeriesMarginChanged(barSeriesMargin());

++ }

++

++ QSizeF QQuickGraphsBars::barSeriesMargin() const

++ {

++     return m_barSeriesMargin;

++ }

++

++ QList<QBar3DSeries *> QQuickGraphsBars::barSeriesList()

++ {

++     QList<QBar3DSeries *> barSeriesList;

++     for (QAbstract3DSeries *abstractSeries : std::as_const(m_seriesList)) {

++         QBar3DSeries *barSeries = qobject_cast<QBar3DSeries *>(abstractSeries);

++         if (barSeries)

++             barSeriesList.append(barSeries);

++     }

++

++     return barSeriesList;

++ }

++

++ QQmlListProperty<QBar3DSeries> QQuickGraphsBars::seriesList()

++ {

++     return QQmlListProperty<QBar3DSeries>(this,

++                                           this,

++                                           &QQuickGraphsBars::appendSeriesFunc,

++                                           &QQuickGraphsBars::countSeriesFunc,

++                                           &QQuickGraphsBars::atSeriesFunc,

++                                           &QQuickGraphsBars::clearSeriesFunc);

++ }

++

++ void QQuickGraphsBars::appendSeriesFunc(QQmlListProperty<QBar3DSeries> *list, QBar3DSeries *series)

++ {

++     reinterpret_cast<QQuickGraphsBars *>(list->data)->addSeries(series);

++ }

++

++ qsizetype QQuickGraphsBars::countSeriesFunc(QQmlListProperty<QBar3DSeries> *list)

++ {

++     return reinterpret_cast<QQuickGraphsBars *>(list->data)->barSeriesList().size();

++ }

++

++ QBar3DSeries *QQuickGraphsBars::atSeriesFunc(QQmlListProperty<QBar3DSeries> *list, qsizetype index)

++ {

++     return reinterpret_cast<QQuickGraphsBars *>(list->data)->barSeriesList().at(index);

++ }

++

++ void QQuickGraphsBars::clearSeriesFunc(QQmlListProperty<QBar3DSeries> *list)

++ {

++     QQuickGraphsBars *declBars = reinterpret_cast<QQuickGraphsBars *>(list->data);

++     QList<QBar3DSeries *> realList = declBars->barSeriesList();

++     qsizetype count = realList.size();

++     for (int i = 0; i < count; i++)

++         declBars->removeSeries(realList.at(i));

++ }

++

++ void QQuickGraphsBars::addSeries(QBar3DSeries *series)

++ {

++     insertSeries(m_seriesList.size(), series);

++     connectSeries(series);

++     if (series->selectedBar() != invalidSelectionPosition())

++         updateSelectedBar();

++

++     if (series->rowAxis())

++         handleMultiAxisChanged(series->rowAxis());

++     if (series->valueAxis())

++         handleMultiAxisChanged(series->valueAxis());

++     if (series->columnAxis())

++         handleMultiAxisChanged(series->columnAxis());

++ }

++

++ void QQuickGraphsBars::removeSeries(QBar3DSeries *series)

++ {

++     if (!series)

++         return;

++

++     bool wasVisible = (series && series->d_func()->m_graph == this && series->isVisible());

++

++     QQuickGraphsItem::removeSeriesInternal(series);

++

++     if (m_selectedBarSeries == series)

++         setSelectedBar(invalidSelectionPosition(), 0, false);

++

++     if (wasVisible)

++         adjustAxisRanges();

++

++     // If primary series is removed, reset it to default

++     if (series == m_primarySeries) {

++         if (m_seriesList.size())

++             m_primarySeries = static_cast<QBar3DSeries *>(m_seriesList.at(0));

++         else

++             m_primarySeries = 0;

++

++         handleDataRowLabelsChanged();

++         handleDataColumnLabelsChanged();

++

++         emit primarySeriesChanged(m_primarySeries);

++     }

++

++     for (auto it = m_slicedBarModels.begin(); it != m_slicedBarModels.end(); it++) {

++         // Remove series also from slice bar list

++         if (it.key() == series)

++             m_slicedBarModels.remove(it.key());

++     }

++

++     removeBarModels();

++     if (m_selectedBarSeries == series)

++         resetClickedStatus();

++     series->setParent(this); // Reparent as removing will leave series parentless

++     disconnectSeries(series);

++ }

++

++ void QQuickGraphsBars::insertSeries(qsizetype index, QBar3DSeries *series)

++ {

++     Q_ASSERT(series && series->type() == QAbstract3DSeries::SeriesType::Bar);

++

++     qsizetype oldSize = m_seriesList.size();

++

++     QQuickGraphsItem::insertSeries(index, series);

++

++     if (oldSize != m_seriesList.size()) {

++         QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(series);

++         if (!oldSize) {

++             m_primarySeries = barSeries;

++             handleDataRowLabelsChanged();

++             handleDataColumnLabelsChanged();

++         }

++

++         if (barSeries->selectedBar() != invalidSelectionPosition())

++             setSelectedBar(barSeries->selectedBar(), barSeries, false);

++

++         if (!oldSize)

++             emit primarySeriesChanged(m_primarySeries);

++     }

++ }

++

++ void QQuickGraphsBars::clearSelection()

++ {

++     setSelectedBar(invalidSelectionPosition(), 0, false);

++ }

++

++ void QQuickGraphsBars::setPrimarySeries(QBar3DSeries *series)

++ {

++     if (!series) {

++         if (m_seriesList.size())

++             series = static_cast<QBar3DSeries *>(m_seriesList.at(0));

++     } else if (!m_seriesList.contains(series)) {

++         // Add nonexistent series.

++         addSeries(series);

++     }

++

++     if (m_primarySeries != series) {

++         m_primarySeries = series;

++         handleDataRowLabelsChanged();

++         handleDataColumnLabelsChanged();

++         emit primarySeriesChanged(m_primarySeries);

++     }

++ }

++

++ QBar3DSeries *QQuickGraphsBars::primarySeries() const

++ {

++     return m_primarySeries;

++ }

++

++ QBar3DSeries *QQuickGraphsBars::selectedSeries() const

++ {

++     return m_selectedBarSeries;

++ }

++

++ void QQuickGraphsBars::setSelectionMode(QtGraphs3D::SelectionFlags mode)

++ {

++     if (mode.testFlag(QtGraphs3D::SelectionFlag::Slice)

++         && (mode.testFlag(QtGraphs3D::SelectionFlag::Row)

++             == mode.testFlag(QtGraphs3D::SelectionFlag::Column))) {

++         qCWarning(lcProperties3D, "%s must specify one of either row or column selection mode"

++                  "in conjunction with slicing mode.",

++                  qUtf8Printable(QLatin1String(__FUNCTION__)));

++     } else {

++         QtGraphs3D::SelectionFlags oldMode = selectionMode();

++

++         QQuickGraphsItem::setSelectionMode(mode);

++

++         if (mode != oldMode) {

++             // Refresh selection upon mode change to ensure slicing is correctly

++             // updated according to series the visibility.

++             setSelectedBar(m_selectedBar, m_selectedBarSeries, true);

++

++             // Special case: Always deactivate slicing when changing away from slice

++             // automanagement, as this can't be handled in setSelectedBar.

++             if (!mode.testFlag(QtGraphs3D::SelectionFlag::Slice)

++                 && oldMode.testFlag(QtGraphs3D::SelectionFlag::Slice)) {

++                 scene()->setSlicingActive(false);

++             }

++         }

++     }

++ }

++

++ void QQuickGraphsBars::handleAxisAutoAdjustRangeChangedInOrientation(

++     QAbstract3DAxis::AxisOrientation orientation, bool autoAdjust)

++ {

++     Q_UNUSED(orientation);

++     Q_UNUSED(autoAdjust);

++     adjustAxisRanges();

++ }

++

++ void QQuickGraphsBars::handleSeriesVisibilityChangedBySender(QObject *sender)

++ {

++     QQuickGraphsItem::handleSeriesVisibilityChangedBySender(sender);

++

++     // Visibility changes may require disabling slicing,

++     // so just reset selection to ensure everything is still valid.

++     setSelectedBar(m_selectedBar, m_selectedBarSeries, false);

++ }

++

++ void QQuickGraphsBars::handleItemLabelVisibleChangedBySender(bool visible, QObject *sender)

++ {

++     auto series = static_cast<QBar3DSeries *>(sender);

++     if (series == m_selectedBarSeries)

++     {

++         itemLabel()->setVisible(visible);

++         if (auto label = sliceItemLabel(); label && isSlicingActive())

++             label->setVisible(visible);

++     }

++ }

++

++ void QQuickGraphsBars::handleAxisRangeChangedBySender(QObject *sender)

++ {

++     // Data window changed

++     if (sender == m_axisX || sender == m_axisZ) {

++         if (sender == m_axisX)

++             handleDataColumnLabelsChanged();

++         if (sender == m_axisZ)

++             handleDataRowLabelsChanged();

++     }

++

++     QQuickGraphsItem::handleAxisRangeChangedBySender(sender);

++

++     setDataDirty(true);

++

++     // Update selected bar - may be moved offscreen

++     setSelectedBar(m_selectedBar, m_selectedBarSeries, false);

++ }

++

++ void QQuickGraphsBars::adjustAxisRanges()

++ {

++     QCategory3DAxis *categoryAxisZ = static_cast<QCategory3DAxis *>(m_axisZ);

++     QCategory3DAxis *categoryAxisX = static_cast<QCategory3DAxis *>(m_axisX);

++     QValue3DAxis *valueAxis = static_cast<QValue3DAxis *>(m_axisY);

++

++     bool adjustZ = (categoryAxisZ && categoryAxisZ->isAutoAdjustRange());

++     bool adjustX = (categoryAxisX && categoryAxisX->isAutoAdjustRange());

++     bool adjustY = (valueAxis && categoryAxisX && categoryAxisZ && valueAxis->isAutoAdjustRange());

++

++     if (adjustZ || adjustX || adjustY) {

++         qsizetype maxRowCount = 0;

++         qsizetype maxColumnCount = 0;

++         float minValue = 0.0f;

++         float maxValue = 0.0f;

++

++         // First figure out row and column counts

++         qsizetype seriesCount = m_seriesList.size();

++         if (adjustZ || adjustX) {

++             for (qsizetype series = 0; series < seriesCount; series++) {

++                 const QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(m_seriesList.at(series));

++                 if (barSeries->isVisible()) {

++                     const QBarDataProxy *proxy = barSeries->dataProxy();

++

++                     if (adjustZ && proxy) {

++                         qsizetype rowCount = proxy->rowCount();

++                         if (rowCount)

++                             rowCount--;

++

++                         maxRowCount = qMax(maxRowCount, rowCount);

++                     }

++

++                     if (adjustX && proxy) {

++                         const QBarDataArray &array = barSeries->dataArray();

++                         qsizetype columnCount = 0;

++                         for (int i = 0; i < array.size(); i++) {

++                             if (columnCount < array.at(i).size())

++                                 columnCount = array.at(i).size();

++                         }

++                         if (columnCount)

++                             columnCount--;

++

++                         maxColumnCount = qMax(maxColumnCount, columnCount);

++                     }

++                 }

++             }

++             // Call private implementations of setRange to avoid unsetting auto adjust

++             // flag

++             if (adjustZ)

++                 categoryAxisZ->d_func()->setRange(0.0f, float(maxRowCount), true);

++             if (adjustX)

++                 categoryAxisX->d_func()->setRange(0.0f, float(maxColumnCount), true);

++         }

++

++         // Now that we know the row and column ranges, figure out the value axis

++         // range

++         if (adjustY) {

++             for (int series = 0; series < seriesCount; series++) {

++                 const QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(m_seriesList.at(series));

++                 if (barSeries->isVisible()) {

++                     const QBarDataProxy *proxy = barSeries->dataProxy();

++                     if (adjustY && proxy) {

++                         QPair<float, float> limits = proxy->d_func()

++                                                          ->limitValues(categoryAxisZ->min(),

++                                                                        categoryAxisZ->max(),

++                                                                        categoryAxisX->min(),

++                                                                        categoryAxisX->max());

++                         if (!series) {

++                             // First series initializes the values

++                             minValue = limits.first;

++                             maxValue = limits.second;

++                         } else {

++                             minValue = qMin(minValue, limits.first);

++                             maxValue = qMax(maxValue, limits.second);

++                         }

++                     }

++                 }

++             }

++

++             if (maxValue < 0.0f)

++                 maxValue = 0.0f;

++             if (minValue > 0.0f)

++                 minValue = 0.0f;

++             if (minValue == 0.0f && maxValue == 0.0f) {

++                 // Only zero value values in data set, set range to something.

++                 minValue = 0.0f;

++                 maxValue = 1.0f;

++             }

++             valueAxis->d_func()->setRange(minValue, maxValue, true);

++         }

++     }

++ }

++

++ void QQuickGraphsBars::setFloorLevel(float level)

++ {

++     if (level == floorLevel()) {

++         qCDebug(lcProperties3D, "%s value is already set to: %.f",

++                 qUtf8Printable(QLatin1String(__FUNCTION__)), level);

++         return;

++     }

++     m_floorLevel = level;

++     setDataDirty(true);

++     m_changeTracker.floorLevelChanged = true;

++     emitNeedRender();

++     emit floorLevelChanged(level);

++ }

++

++ float QQuickGraphsBars::floorLevel() const

++ {

++     return m_floorLevel;

++ }

++

++ QQuick3DViewport *QQuickGraphsBars::createOffscreenSliceView(int requestedIndex,

++                                                              QtGraphs3D::SliceCaptureType sliceType)

++ {

++     QQuick3DViewport *sliceView = QQuickGraphsItem::createOffscreenSliceView(sliceType);

++

++     Q_TRACE_SCOPE(QGraphs3DBarsCreateOffscreenSliceView, requestedIndex,

++                   static_cast<int>(sliceType));

++

++     const bool isRow = (sliceType == QtGraphs3D::SliceCaptureType::RowImage);

++     const bool isColumn = (sliceType == QtGraphs3D::SliceCaptureType::ColumnImage);

++

++     QList<QBar3DSeries *> barSeriesList = this->barSeriesList();

++     for (const auto &barSeries : std::as_const(barSeriesList)) {

++         qsizetype newRowSize = qMin(barSeries->dataProxy()->rowCount() - m_minRow, m_newRows);

++         qsizetype newColSize = 0;

++         if (newRowSize) {

++             const QBarDataRow *dataRow = &barSeries->dataProxy()->rowAt(m_minRow);

++             if (dataRow) {

++                 qsizetype dataColIndex = m_minCol;

++                 newColSize = qMin(dataRow->size() - dataColIndex, m_newCols);

++             }

++         }

++

++         if (!barSeries->isVisible())

++             continue;

++

++         if (requestedIndex < 0 || requestedIndex >= newRowSize || requestedIndex >= newColSize) {

++             qCWarning(lcEvents3D, "%s the index is out of range. The render stops.",

++                       qUtf8Printable(QLatin1String(__FUNCTION__)));

++             sliceView->setVisible(false);

++             sliceView->deleteLater();

++             return nullptr;

++         }

++

++         qsizetype slicedBarListSize = -1;

++

++         if (isRow)

++             slicedBarListSize = newColSize;

++         else if (isColumn)

++             slicedBarListSize = newRowSize;

++

++         if (slicedBarListSize < 0)

++             return nullptr;

++

++         QList<BarModel *> barList = *m_barModelsMap.value(barSeries);

++         bool useGradient = barSeries->d_func()->isUsingGradient();

++         bool rangeGradient =

++                 (useGradient

++                  && barSeries->d_func()->m_colorStyle == QGraphsTheme::ColorStyle::RangeGradient);

++

++         QQuick3DModel *model = nullptr;

++         QList<BarItemHolder *> barItemHolderList;

++         QList<BarItemHolder *> barItemList;

++         QList<BarItemHolder *> selectedItems;

++         if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++             model = new QQuick3DModel();

++             model->setParent(sliceView->scene());

++             model->setParentItem(sliceView->scene());

++             model->setObjectName(QStringLiteral("BarModel"));

++             QString fileName = getMeshFileName();

++             if (fileName.isEmpty())

++                 fileName = barSeries->userDefinedMesh();

++

++             model->setSource(QUrl(fileName));

++

++             auto barInstancing = new BarInstancing;

++             barInstancing->setParent(barSeries);

++             model->setInstancing(barInstancing);

++

++             BarModel *barListItem = barList.at(0);

++             updateItemMaterial(model, useGradient, rangeGradient,

++                                QStringLiteral(":/materials/BarsMaterialInstancing"));

++             updateMaterialProperties(model, false, false, barListItem->texture,

++                                      barSeries->baseColor());

++

++             barItemList = barListItem->instancing->dataArray();

++             for (const auto bih : std::as_const(barItemList)) {

++                 if (!((isRow && bih->coord.x() == requestedIndex)

++                       || (isColumn && bih->coord.y() == requestedIndex)))

++                     continue;

++

++                 BarItemHolder *selectedBih = new BarItemHolder();

++                 selectedBih->selectedBar = false;

++                 selectedBih->coord = bih->coord;

++                 selectedBih->rotation = bih->rotation;

++                 selectedBih->heightValue = bih->heightValue;

++                 selectedBih->position = bih->position;

++                 selectedBih->scale = bih->scale;

++

++                 selectedItems.push_back(selectedBih);

++             }

++             if (selectedItems.size() == 0)

++                 continue;

++         }

++

++         qsizetype index = 0;

++         for (int ind = 0; ind < slicedBarListSize; ++ind) {

++             if (isRow)

++                 index = (requestedIndex * barSeries->dataProxy()->colCount()) + ind;

++             else

++                 index = requestedIndex + (ind * barSeries->dataProxy()->colCount());

++

++             if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++                 if (index > barList.size())

++                     return nullptr;

++                 model = createDataItem(sliceView->scene(), barSeries);

++                 BarModel *barModel = barList.at(index);

++                 if (isRow) {

++                     model->setPosition(QVector3D(barModel->model->x(), barModel->model->y(), 0.0f));

++                 } else {

++                     model->setX(barModel->model->z() - (barList.at(0)->visualIndex * .1f));

++                     model->setY(barModel->model->y());

++                     model->setZ(0.0f);

++                 }

++                 model->setScale(barModel->model->scale());

++

++                 updateItemMaterial(model, useGradient, rangeGradient,

++                                    QStringLiteral(":/materials/BarsMaterial"));

++

++                 updateMaterialProperties(model, false, false, barList.at(index)->texture,

++                                          barSeries->baseColor());

++             } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                 BarModel *barModel = barList.at(0);

++                 BarItemHolder *itemHolder = new BarItemHolder();

++                 itemHolder->selectedBar = false;

++                 itemHolder->color = barSeries->baseColor();

++                 itemHolder->coord = barModel->coord;

++                 itemHolder->rotation = selectedItems.at(ind)->rotation;

++                 itemHolder->heightValue = barModel->heightValue;

++                 itemHolder->position = selectedItems.at(ind)->position;

++                 itemHolder->scale = selectedItems.at(ind)->scale;

++

++                 if (isRow) {

++                     itemHolder->position.setZ(.0f);

++                 } else {

++                     itemHolder->position.setX(itemHolder->position.z()

++                                                - (barModel->visualIndex * .1f));

++                     itemHolder->position.setZ(.0f);

++                 }

++

++                 barItemHolderList.push_back(itemHolder);

++             }

++         }

++

++         if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++             BarInstancing *instancing = static_cast<BarInstancing *>(model->instancing());

++             instancing->setDataArray(barItemHolderList);

++         }

++     }

++

++     return sliceView;

++ }

++

++ void QQuickGraphsBars::renderSliceToImage(int requestedIndex,

++                                           QtGraphs3D::SliceCaptureType sliceType)

++ {

++     QQuick3DViewport *sliceView = createOffscreenSliceView(requestedIndex, sliceType);

++

++     if (!m_grabresult)

++         m_grabresult = new QImage();

++

++     if (sliceView) {

++         QSharedPointer<QQuickItemGrabResult> grabbed = sliceView->grabToImage();

++         connect(grabbed.data(), &QQuickItemGrabResult::ready, this, [&, grabbed, sliceView]() {

++             sliceView->setVisible(false);

++             sliceView->deleteLater();

++             *m_grabresult = grabbed.data()->image();

++             emit sliceImageChanged(*m_grabresult);

++         });

++     }

++ }

++

++ void QQuickGraphsBars::renderSliceToImage(int requestedIndex,

++                                           QtGraphs3D::SliceCaptureType sliceType,

++                                           const QUrl &filePath)

++ {

++     QQuick3DViewport *sliceView = createOffscreenSliceView(requestedIndex, sliceType);

++

++     if (!sliceView)

++         return;

++

++     if (filePath.isEmpty()) {

++         qCWarning(lcGraphsBars3D, "Save path is not defined.");

++         sliceView->setVisible(false);

++         sliceView->deleteLater();

++         return;

++     }

++

++     QSharedPointer<QQuickItemGrabResult> grabbed = sliceView->grabToImage();

++     connect(grabbed.data(), &QQuickItemGrabResult::ready, this, [grabbed, sliceView, filePath]() {

++         if (!grabbed.data()->saveToFile(filePath))

++             qCWarning(lcGraphsBars3D, "Saving requested slice view to image failed");

++         sliceView->setVisible(false);

++         sliceView->deleteLater();

++     });

++

++     return;

++ }

++

++ void QQuickGraphsBars::componentComplete()

++ {

++     QQuickGraphsItem::componentComplete();

++     if (!isReady())

++         return;

++

++     auto wallBackground = background();

++     QUrl wallUrl = QUrl(QStringLiteral("defaultMeshes/backgroundNoFloorMesh"));

++     wallBackground->setSource(wallUrl);

++     setBackground(wallBackground);

++

++     QUrl floorUrl = QUrl(QStringLiteral(":/defaultMeshes/barMeshFull"));

++     m_floorBackground = new QQuick3DModel();

++     m_floorBackgroundScale = new QQuick3DNode();

++     m_floorBackgroundRotation = new QQuick3DNode();

++

++     m_floorBackgroundScale->setParent(graphNode());

++     m_floorBackgroundScale->setParentItem(graphNode());

++

++     m_floorBackgroundRotation->setParent(m_floorBackgroundScale);

++     m_floorBackgroundRotation->setParentItem(m_floorBackgroundScale);

++

++     m_floorBackground->setObjectName("Floor Background");

++     m_floorBackground->setParent(m_floorBackgroundRotation);

++     m_floorBackground->setParentItem(m_floorBackgroundRotation);

++

++     m_floorBackground->setSource(floorUrl);

++     m_floorBackground->setPickable(false);

++

++     setFloorGridInRange(true);

++     setVerticalSegmentLine(false);

++

++     QObject::connect(cameraTarget(),

++                      &QQuick3DNode::rotationChanged,

++                      this,

++                      &QQuickGraphsBars::handleCameraRotationChanged);

++

++     graphsInputHandler()->setGraphsItem(this);

++ }

++

++ void QQuickGraphsBars::synchData()

++ {

++     qCDebug(lcGraphs3D, "%s start of sync", qUtf8Printable(QLatin1String(__FUNCTION__)));

++     if (!isReady())

++         return;

++

++     Q_TRACE(QGraphs3DBarsSynch_entry_beforeGraphsItem);

++

++     if (m_changeTracker.barSpecsChanged || !m_cachedBarThickness.isValid()) {

++         updateBarSpecs(m_barThicknessRatio, m_barSpacing, m_isBarSpecRelative);

++         m_changeTracker.barSpecsChanged = false;

++     }

++

++     // Floor level update requires data update, so do before qquickgraphicsitem sync

++     if (m_changeTracker.floorLevelChanged) {

++         updateFloorLevel(m_floorLevel);

++         // Update labels and grid as well, unless we are in shader grid mode

++         updateLabels();

++         if (gridLineType() != QtGraphs3D::GridLineType::Shader)

++             updateGrid();

++         m_changeTracker.floorLevelChanged = false;

++     }

++

++     if (m_changeTracker.multiSeriesScalingChanged) {

++         m_keepSeriesUniform = m_isMultiSeriesUniform;

++         setSeriesVisualsDirty(true);

++         m_changeTracker.multiSeriesScalingChanged = false;

++     }

++

++     // Do not clear dirty flag, we need to react to it in qquickgraphicsitem as well

++     if (theme()->dirtyBits()->plotAreaBackgroundVisibilityDirty) {

++         setSeriesVisualsDirty(true);

++         for (auto it = m_barModelsMap.begin(); it != m_barModelsMap.end(); it++)

++             it.key()->d_func()->m_changeTracker.meshChanged = true;

++     }

++

++     if (m_changeTracker.barSeriesMarginChanged) {

++         updateBarSeriesMargin(barSeriesMargin());

++         m_changeTracker.barSeriesMarginChanged = false;

++     }

++

++     if (m_changeTracker.axisRangeChanged) {

++         adjustAxisRanges();

++         m_changeTracker.axisRangeChanged = false;

++     }

++     Q_TRACE(QGraphs3DBarsSynch_exit_beforeGraphsItem);

++

++     QQuickGraphsItem::synchData();

++

++     Q_TRACE(QGraphs3DBarsSynch_entry_afterGraphsItem);

++

++     if (m_selectedBarPos.isNull())

++         itemLabel()->setVisible(false);

++

++     // Draw floor

++     if (m_changeTracker.floorChanged) {

++         updateFloor();

++         m_changeTracker.floorChanged = false;

++     }

++

++     Q_TRACE(QGraphs3DBarsSynch_exit_afterGraphsItem);

++     qCDebug(lcGraphs3D, "%s end syncing", qUtf8Printable(QLatin1String(__FUNCTION__)));

++ }

++

++ void QQuickGraphsBars::updateFloor()

++ {

++     auto min = qMin(scaleWithBackground().x(), scaleWithBackground().z());

++     m_floorBackgroundScale->setScale(QVector3D(

++         scaleWithBackground().x() + m_hBackgroundMargin,

++         min * gridOffset(),

++         scaleWithBackground().z() + m_hBackgroundMargin));

++     m_floorBackgroundScale->setPosition(QVector3D(0.0f, -m_backgroundAdjustment, 0.0f));

++

++     QQuaternion m_xRightAngleRotation(QQuaternion::fromAxisAndAngle(1.0f, 0.0f, 0.0f, 90.0f));

++     QQuaternion m_xRightAngleRotationNeg(QQuaternion::fromAxisAndAngle(1.0f, 0.0f, 0.0f, -90.0f));

++

++     if (isYFlipped())

++         m_floorBackgroundRotation->setRotation(m_xRightAngleRotation);

++     else

++         m_floorBackgroundRotation->setRotation(m_xRightAngleRotationNeg);

++

++     QQmlListReference materialsRefF(m_floorBackground, "materials");

++     QQmlListReference bbRef(background(), "materials");

++     QQuick3DCustomMaterial *bgMatFloor;

++     if (!materialsRefF.size() && bbRef.size()) {

++         bgMatFloor = static_cast<QQuick3DCustomMaterial *>(bbRef.at(0));

++         materialsRefF.append(bgMatFloor);

++     }

++ }

++

++ void QQuickGraphsBars::updateParameters()

++ {

++     m_minRow = m_axisZ->min();

++     m_maxRow = m_axisZ->max();

++     m_minCol = m_axisX->min();

++     m_maxCol = m_axisX->max();

++     m_newRows = m_maxRow - m_minRow + 1;

++     m_newCols = m_maxCol - m_minCol + 1;

++

++     if (m_cachedRowCount != m_newRows || m_cachedColumnCount != m_newCols) {

++         m_changeTracker.selectedBarChanged = true;

++         m_cachedColumnCount = m_newCols;

++         m_cachedRowCount = m_newRows;

++

++         // Calculate max scene size

++         float sceneRatio = qMin(float(m_newCols) / float(m_newRows),

++                                 float(m_newRows) / float(m_newCols));

++         m_maxSceneSize = 2.0f * qSqrt(sceneRatio * m_newCols * m_newRows);

++

++         if (m_cachedBarThickness.isValid())

++             calculateSceneScalingFactors();

++     }

++     m_changeTracker.axisRangeChanged = true;

++     setDataDirty(true);

++ }

++

++ void QQuickGraphsBars::updateFloorLevel(float level)

++ {

++     setFloorLevel(level);

++     calculateHeightAdjustment();

++ }

++

++ void QQuickGraphsBars::updateGraph()

++ {

++     Q_TRACE_SCOPE(QGraphs3DBarsGenerateBarsUpdateGraph);

++

++     QList<QBar3DSeries *> barSeriesAsList = barSeriesList();

++     calculateSceneScalingFactors();

++

++     for (const auto &series : std::as_const(barSeriesAsList)) {

++         QAbstract3DSeriesChangeBitField &changeTracker = series->d_func()->m_changeTracker;

++         if (changeTracker.meshChanged || changeTracker.meshSmoothChanged) {

++             changeTracker.meshChanged = false;

++             changeTracker.meshSmoothChanged = false;

++             setDataDirty(true);

++         }

++     }

++

++     if (isDataDirty()) {

++         removeBarModels();

++         generateBars(barSeriesAsList);

++     }

++

++     if (isSeriesVisualsDirty()) {

++         int visualIndex = 0;

++         for (const auto &barSeries : std::as_const(barSeriesAsList)) {

++             if (barSeries->isVisible()) {

++                 updateBarVisuality(barSeries, visualIndex);

++                 updateBarPositions(barSeries);

++                 updateBarVisuals(barSeries);

++                 ++visualIndex;

++             } else {

++                 updateBarVisuality(barSeries, -1);

++             }

++         }

++     }

++

++     // Needs to be done after data is set, as it needs to know the visual array.

++     if (m_changeTracker.selectedBarChanged) {

++         updateSelectedBar();

++         setItemSelected(m_selectedBar != invalidSelectionPosition());

++         if (isSliceEnabled()) {

++             createSliceView();

++             for (const auto &series : std::as_const(barSeriesAsList)) {

++                 bool visible = (m_selectedBarSeries == series) && series->isVisible();

++                 if (sliceView()->isVisible()) {

++                     if (visible) {

++                         removeSlicedBarModels();

++                         createSliceView();

++                         setSliceActivatedChanged(false);

++                         toggleSliceGraph();

++                         break;

++                     } else {

++                         setSliceActivatedChanged(true);

++                     }

++                 } else {

++                     if (visible) {

++                         m_selectionDirty = true;

++                         setSliceActivatedChanged(true);

++                     }

++                 }

++             }

++         }

++         m_changeTracker.selectedBarChanged = false;

++     }

++

++     setDataDirty(false);

++     setSeriesVisualsDirty(false);

++ }

++

++ void QQuickGraphsBars::updateAxisRange(float min, float max)

++ {

++     QQuickGraphsItem::updateAxisRange(min, max);

++     calculateHeightAdjustment();

++ }

++

++ void QQuickGraphsBars::updateAxisReversed(bool enable)

++ {

++     Q_UNUSED(enable);

++     setSeriesVisualsDirty(true);

++     calculateHeightAdjustment();

++ }

++

++ void QQuickGraphsBars::updateLightStrength()

++ {

++     for (const auto list : std::as_const(m_barModelsMap)) {

++         for (auto barModel : std::as_const(*list)) {

++             QQmlListReference materialRef(barModel->model, "materials");

++             if (materialRef.size()) {

++                 QQuick3DCustomMaterial *material = qobject_cast<QQuick3DCustomMaterial *>(

++                     materialRef.at(0));

++                 material->setProperty("specularBrightness", lightStrength() * 0.05);

++             }

++         }

++     }

++ }

++

++ void QQuickGraphsBars::calculateSceneScalingFactors()

++ {

++     m_rowWidth = (m_cachedColumnCount * m_cachedBarSpacing.width()) * 0.5f;

++     m_columnDepth = (m_cachedRowCount * m_cachedBarSpacing.height()) * 0.5f;

++     m_maxDimension = qMax(m_rowWidth, m_columnDepth);

++     m_scaleFactor = qMin((m_cachedColumnCount * (m_maxDimension / m_maxSceneSize)),

++                          (m_cachedRowCount * (m_maxDimension / m_maxSceneSize)));

++

++     // Single bar scaling

++     m_xScale = m_cachedBarThickness.width() / m_scaleFactor;

++     m_zScale = m_cachedBarThickness.height() / m_scaleFactor;

++

++     // Adjust scaling according to margin

++     m_xScale = m_xScale - m_xScale * m_cachedBarSeriesMargin.width();

++     m_zScale = m_zScale - m_zScale * m_cachedBarSeriesMargin.height();

++

++     // Whole graph scale factors

++     m_xScaleFactor = m_rowWidth / m_scaleFactor;

++     m_zScaleFactor = m_columnDepth / m_scaleFactor;

++

++     if (margin() < 0.0f) {

++         m_hBackgroundMargin = 0.0f;

++         m_vBackgroundMargin = 0.0f;

++     } else {

++         m_hBackgroundMargin = margin();

++         m_vBackgroundMargin = margin();

++     }

++

++     // Margin for a line to be fully visible on the edge in the grid shader

++     const float halfLineWidth = 50.0;

++     const float gridTextureSize = 4096.0;

++     const float gridMargin = halfLineWidth / gridTextureSize;

++     m_hBackgroundMargin += gridMargin;

++     m_vBackgroundMargin += gridMargin;

++

++     auto scale = QVector3D(m_xScaleFactor, 1.0f, m_zScaleFactor);

++     setScaleWithBackground(scale);

++     setBackgroundScaleMargin({m_hBackgroundMargin, m_vBackgroundMargin, m_hBackgroundMargin});

++     setScale(scale);

++     m_changeTracker.floorChanged = true;

++ }

++

++ void QQuickGraphsBars::calculateHeightAdjustment()

++ {

++     float newAdjustment = 1.0f;

++     m_actualFloorLevel = qBound(valueAxis()->min(), floorLevel(), valueAxis()->max());

++     float maxAbs = qFabs(valueAxis()->max() - m_actualFloorLevel);

++

++     // Check if we have negative values

++     if (valueAxis()->min() < m_actualFloorLevel)

++         m_hasNegativeValues = true;

++     else if (valueAxis()->min() >= m_actualFloorLevel)

++         m_hasNegativeValues = false;

++

++     // Check first if user has set the ranges

++     if (!isUserCameraRotationRange()) {

++         // If not, adjust them automatically based on possibly existing negative values

++         if (!m_noZeroInRange) {

++             setMinCameraYRotation(-90.0f);

++             setMaxCameraYRotation(90.0f);

++         } else {

++             if ((m_hasNegativeValues && !valueAxis()->reversed())

++                 || (!m_hasNegativeValues && valueAxis()->reversed())) {

++                 setMinCameraYRotation(-90.0f);

++                 setMaxCameraYRotation(0.0f);

++             } else {

++                 setMinCameraYRotation(0.0f);

++                 setMaxCameraYRotation(90.0f);

++             }

++         }

++         setUserCameraRotationRange(false);

++     }

++

++     if (valueAxis()->max() < m_actualFloorLevel) {

++         m_heightNormalizer = float(qFabs(valueAxis()->min()) - qFabs(valueAxis()->max()));

++         maxAbs = qFabs(valueAxis()->max()) - qFabs(valueAxis()->min());

++     } else {

++         m_heightNormalizer = float(valueAxis()->max() - valueAxis()->min());

++     }

++

++     // Height fractions are used in gradient calculations and are therefore

++     // doubled Note that if max or min is exactly zero, we still consider it

++     // outside the range

++     if (valueAxis()->max() <= m_actualFloorLevel || valueAxis()->min() >= m_actualFloorLevel)

++         m_noZeroInRange = true;

++     else

++         m_noZeroInRange = false;

++

++     // Calculate translation adjustment for background floor

++     newAdjustment = (qBound(0.0f, (maxAbs / m_heightNormalizer), 1.0f) - 0.5f) * 2.0f;

++     if (valueAxis()->reversed())

++         newAdjustment = -newAdjustment;

++

++     if (newAdjustment != m_backgroundAdjustment)

++         m_backgroundAdjustment = newAdjustment;

++ }

++

++ void QQuickGraphsBars::calculateSeriesStartPosition()

++ {

++     m_seriesStart = -((float(m_visibleSeriesCount) - 1.0f) * 0.5f)

++                     * (m_seriesStep - (m_seriesStep * m_cachedBarSeriesMargin.width()));

++ }

++

++ QVector3D QQuickGraphsBars::calculateCategoryLabelPosition(QAbstract3DAxis *axis,

++                                                            QVector3D labelPosition,

++                                                            int index)

++ {

++     QVector3D ret = labelPosition;

++     if (axis->orientation() == QAbstract3DAxis::AxisOrientation::X) {

++         float xPos = (index + 0.5f) * m_cachedBarSpacing.width();

++         ret.setX((xPos - m_rowWidth) / m_scaleFactor);

++     }

++     if (axis->orientation() == QAbstract3DAxis::AxisOrientation::Z) {

++         float zPos = (index + 0.5f) * m_cachedBarSpacing.height();

++         ret.setZ((m_columnDepth - zPos) / m_scaleFactor);

++     }

++     ret.setY(-m_backgroundAdjustment);

++     return ret;

++ }

++

++ float QQuickGraphsBars::calculateCategoryGridLinePosition(QAbstract3DAxis *axis, int index)

++ {

++     float ret = 0.0f;

++     if (axis->orientation() == QAbstract3DAxis::AxisOrientation::Z) {

++         float colPos = index * -(m_cachedBarSpacing.height() / m_scaleFactor);

++         ret = colPos + scale().z();

++     }

++     if (axis->orientation() == QAbstract3DAxis::AxisOrientation::X) {

++         float rowPos = index * (m_cachedBarSpacing.width() / m_scaleFactor);

++         ret = rowPos - scale().x();

++     }

++     if (axis->orientation() == QAbstract3DAxis::AxisOrientation::Y)

++         ret = -m_backgroundAdjustment;

++     return ret;

++ }

++

++ void QQuickGraphsBars::handleAxisXChanged(QAbstract3DAxis *axis)

++ {

++     emit columnAxisChanged(static_cast<QCategory3DAxis *>(axis));

++ }

++

++ void QQuickGraphsBars::handleAxisYChanged(QAbstract3DAxis *axis)

++ {

++     emit valueAxisChanged(static_cast<QValue3DAxis *>(axis));

++ }

++

++ void QQuickGraphsBars::handleAxisZChanged(QAbstract3DAxis *axis)

++ {

++     emit rowAxisChanged(static_cast<QCategory3DAxis *>(axis));

++ }

++

++ void QQuickGraphsBars::handleMultiAxisChanged(QAbstract3DAxis *axis)

++ {

++     QQuickGraphsItem::handleMultiAxisChanged(axis);

++ }

++

++ QAbstract3DAxis *QQuickGraphsBars::getSeriesMultiAxis(QAbstract3DSeries *series,

++                    QAbstract3DAxis::AxisOrientation orientation)

++ {

++     QBar3DSeries *barSeries = qobject_cast<QBar3DSeries *>(series);

++

++     if (!barSeries)

++         return nullptr;

++

++     QAbstract3DAxis *axis = nullptr;

++     switch (orientation)  {

++     case QAbstract3DAxis::AxisOrientation::X:

++         axis = barSeries->rowAxis();

++     break;

++     case QAbstract3DAxis::AxisOrientation::Y:

++         axis = barSeries->valueAxis();

++     break;

++     case QAbstract3DAxis::AxisOrientation::Z:

++         axis = barSeries->columnAxis();

++     break;

++     case QAbstract3DAxis::AxisOrientation::None:

++     break;

++     }

++

++     if (axis)

++         axis->d_func()->setOrientation(orientation);

++

++     return axis;

++ }

++

++ void QQuickGraphsBars::handleSeriesMeshChanged(QAbstract3DSeries::Mesh mesh)

++ {

++     m_meshType = mesh;

++ }

++

++ void QQuickGraphsBars::handleMeshSmoothChanged(bool enable)

++ {

++     m_smooth = enable;

++ }

++

++ void QQuickGraphsBars::handleCameraRotationChanged()

++ {

++     updateLabels();

++ }

++

++ void QQuickGraphsBars::handleArrayReset()

++ {

++     QBar3DSeries *series;

++     if (qobject_cast<QBarDataProxy *>(sender()))

++         series = static_cast<QBarDataProxy *>(sender())->series();

++     else

++         series = static_cast<QBar3DSeries *>(sender());

++

++     if (series->isVisible()) {

++         adjustAxisRanges();

++         setDataDirty(true);

++         series->d_func()->markItemLabelDirty();

++     }

++     if (!m_changedSeriesList.contains(series))

++         m_changedSeriesList.append(series);

++     // Clear selection unless still valid

++     setSelectedBar(m_selectedBar, m_selectedBarSeries, false);

++     series->d_func()->markItemLabelDirty();

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::handleRowsAdded(qsizetype startIndex, qsizetype count)

++ {

++     Q_UNUSED(startIndex);

++     Q_UNUSED(count);

++     QBar3DSeries *series = static_cast<QBarDataProxy *>(sender())->series();

++     if (series->isVisible()) {

++         adjustAxisRanges();

++         setDataDirty(true);

++     }

++     if (!m_changedSeriesList.contains(series))

++         m_changedSeriesList.append(series);

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::handleRowsChanged(qsizetype startIndex, qsizetype count)

++ {

++     QBar3DSeries *series = static_cast<QBarDataProxy *>(sender())->series();

++     qsizetype oldChangeCount = m_changedRows.size();

++     if (!oldChangeCount)

++         m_changedRows.reserve(count);

++

++     for (int i = 0; i < count; i++) {

++         bool newItem = true;

++         qsizetype candidate = startIndex + i;

++         for (qsizetype j = 0; j < oldChangeCount; j++) {

++             const ChangeRow &oldChangeItem = m_changedRows.at(j);

++             if (oldChangeItem.row == candidate && series == oldChangeItem.series) {

++                 newItem = false;

++                 break;

++             }

++         }

++         if (newItem) {

++             ChangeRow newChangeItem = {series, candidate};

++             m_changedRows.append(newChangeItem);

++             if (series == m_selectedBarSeries && m_selectedBar.x() == candidate)

++                 series->d_func()->markItemLabelDirty();

++         }

++     }

++     if (count) {

++         m_changeTracker.rowsChanged = true;

++

++         if (series->isVisible())

++             adjustAxisRanges();

++

++         // Clear selection unless still valid (row length might have changed)

++         setSelectedBar(m_selectedBar, m_selectedBarSeries, false);

++         emitNeedRender();

++     }

++ }

++

++ void QQuickGraphsBars::handleRowsRemoved(qsizetype startIndex, qsizetype count)

++ {

++     Q_UNUSED(startIndex);

++     Q_UNUSED(count);

++

++     QBar3DSeries *series = static_cast<QBarDataProxy *>(sender())->series();

++     if (series == m_selectedBarSeries) {

++         // If rows removed from selected series before the selection, adjust the

++         // selection

++         int selectedRow = m_selectedBar.x();

++         if (startIndex <= selectedRow) {

++             if ((startIndex + count) > selectedRow)

++                 selectedRow = -1; // Selected row removed

++             else

++                 selectedRow -= count; // Move selected row down by amount of rows removed

++

++             setSelectedBar(QPoint(selectedRow, m_selectedBar.y()), m_selectedBarSeries, false);

++         }

++     }

++

++     if (series->isVisible()) {

++         adjustAxisRanges();

++         setDataDirty(true);

++     }

++     if (!m_changedSeriesList.contains(series))

++         m_changedSeriesList.append(series);

++

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::handleRowsInserted(qsizetype startIndex, qsizetype count)

++ {

++     Q_UNUSED(startIndex);

++     Q_UNUSED(count);

++     QBar3DSeries *series = static_cast<QBarDataProxy *>(sender())->series();

++     if (series == m_selectedBarSeries) {

++         // If rows inserted to selected series before the selection, adjust the

++         // selection

++         int selectedRow = m_selectedBar.x();

++         if (startIndex <= selectedRow) {

++             selectedRow += count;

++             setSelectedBar(QPoint(selectedRow, m_selectedBar.y()), m_selectedBarSeries, false);

++         }

++     }

++

++     if (series->isVisible()) {

++         adjustAxisRanges();

++         setDataDirty(true);

++     }

++     if (!m_changedSeriesList.contains(series))

++         m_changedSeriesList.append(series);

++

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::handleItemChanged(qsizetype rowIndex, qsizetype columnIndex)

++ {

++     QBar3DSeries *series = static_cast<QBarDataProxy *>(sender())->series();

++

++     bool newItem = true;

++     QPoint candidate((int(rowIndex)), (int(columnIndex)));

++     for (ChangeItem item : std::as_const(m_changedItems)) {

++         if (item.point == candidate && item.series == series) {

++             newItem = false;

++             setDataDirty(true);

++             break;

++         }

++     }

++

++     if (newItem) {

++         ChangeItem newItem = {series, candidate};

++         m_changedItems.append(newItem);

++         m_changeTracker.itemChanged = true;

++

++         if (series == m_selectedBarSeries && m_selectedBar == candidate)

++             series->d_func()->markItemLabelDirty();

++         if (series->isVisible())

++             adjustAxisRanges();

++     }

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::handleDataRowLabelsChanged()

++ {

++     if (m_axisZ) {

++         // Grab a sublist equal to data window (no need to have more labels in axis)

++         int min = int(m_axisZ->min());

++         int count = int(m_axisZ->max()) - min + 1;

++         QStringList subList;

++         if (m_primarySeries && m_primarySeries->dataProxy())

++             subList = m_primarySeries->rowLabels().mid(min, count);

++         static_cast<QCategory3DAxis *>(m_axisZ)->d_func()->setDataLabels(subList);

++     }

++

++     if (repeaterZ()) {

++         updateParameters();

++         repeaterZ()->setModel(m_axisZ->labels().size());

++     }

++ }

++

++ void QQuickGraphsBars::handleDataColumnLabelsChanged()

++ {

++     if (m_axisX) {

++         // Grab a sublist equal to data window (no need to have more labels in axis)

++         int min = int(m_axisX->min());

++         int count = int(m_axisX->max()) - min + 1;

++         QStringList subList;

++         if (m_primarySeries && m_primarySeries->dataProxy())

++             subList = m_primarySeries->columnLabels().mid(min, count);

++         static_cast<QCategory3DAxis *>(m_axisX)->d_func()->setDataLabels(subList);

++     }

++

++     if (repeaterX()) {

++         updateParameters();

++         repeaterX()->setModel(m_axisX->labels().size());

++     }

++ }

++

++ void QQuickGraphsBars::handleRowColorsChanged()

++ {

++     setSeriesVisualsDirty(true);

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::handleValueColoringChanged()

++ {

++     setSeriesVisualsDirty(true);

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::handleLightingModeChanged()

++ {

++     setSeriesVisualsDirty(true);

++     emitNeedRender();

++ }

++

++ void QQuickGraphsBars::connectSeries(QBar3DSeries *series)

++ {

++     m_meshType = series->mesh();

++     m_smooth = series->isMeshSmooth();

++

++     QObject::connect(series,

++                      &QBar3DSeries::meshChanged,

++                      this,

++                      &QQuickGraphsBars::handleSeriesMeshChanged);

++     QObject::connect(series,

++                      &QBar3DSeries::meshSmoothChanged,

++                      this,

++                      &QQuickGraphsBars::handleMeshSmoothChanged);

++     QObject::connect(series->dataProxy(),

++                      &QBarDataProxy::colCountChanged,

++                      this,

++                      &QQuickGraphsBars::handleDataColumnLabelsChanged);

++     QObject::connect(series->dataProxy(),

++                      &QBarDataProxy::rowCountChanged,

++                      this,

++                      &QQuickGraphsBars::handleDataRowLabelsChanged);

++     QObject::connect(series,

++                      &QBar3DSeries::rowColorsChanged,

++                      this,

++                      &QQuickGraphsBars::handleRowColorsChanged);

++     QObject::connect(series,

++                      &QBar3DSeries::valueColoringEnabledChanged,

++                      this,

++                      &QQuickGraphsBars::handleValueColoringChanged);

++     QObject::connect(series,

++                      &QBar3DSeries::rowAxisChanged,

++                      this,

++                      &QQuickGraphsBars::handleMultiAxisChanged);

++     QObject::connect(series,

++                      &QBar3DSeries::valueAxisChanged,

++                      this,

++                      &QQuickGraphsBars::handleMultiAxisChanged);

++     QObject::connect(series,

++                      &QBar3DSeries::columnAxisChanged,

++                      this,

++                      &QQuickGraphsBars::handleMultiAxisChanged);

++

++ }

++

++ void QQuickGraphsBars::disconnectSeries(QBar3DSeries *series)

++ {

++     QObject::disconnect(series, 0, this, 0);

++ }

++

++ void QQuickGraphsBars::generateBars(QList<QBar3DSeries *> &barSeriesList)

++ {

++     m_visibleSeriesCount = 0;

++     Q_TRACE_SCOPE(QGraphs3DBarsGenerateBars, barSeriesList.size());

++

++     for (const auto &barSeries : std::as_const(barSeriesList)) {

++         QQuick3DTexture *texture = createTexture();

++         texture->setParent(this);

++         auto gradient = barSeries->baseGradient();

++         auto textureData = static_cast<QQuickGraphsTextureData *>(texture->textureData());

++         textureData->createGradient(gradient);

++

++         bool visible = barSeries->isVisible();

++

++         QList<BarModel *> *barList = m_barModelsMap.value(barSeries);

++

++         if (!barList) {

++             barList = new QList<BarModel *>;

++             m_barModelsMap[barSeries] = barList;

++         }

++

++         if (barList->isEmpty()) {

++             if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++                 QBarDataProxy *dataProxy = barSeries->dataProxy();

++                 qsizetype dataRowIndex = m_minRow;

++                 qsizetype newRowSize = qMin(dataProxy->rowCount() - dataRowIndex, m_newRows);

++                 Q_TRACE_SCOPE(QGraphs3DBarsGenerateBarsLegacy);

++

++                 for (int row = 0; row < newRowSize; ++row) {

++                     const QBarDataRow &dataRow = dataProxy->rowAt(dataRowIndex);

++                     if (!dataRow.isEmpty()) {

++                         qsizetype dataColIndex = m_minCol;

++                         qsizetype newColSize = qMin(dataRow.size() - dataColIndex, m_newCols);

++                         for (int col = 0; col < newColSize; ++col) {

++                             QBarDataItem &dataItem = const_cast<QBarDataItem &>(

++                                 dataRow.at(dataColIndex));

++                             auto scene = graphNode();

++                             QQuick3DModel *model = createDataItem(scene, barSeries);

++                             model->setVisible(visible);

++

++                             BarModel *barModel = new BarModel();

++                             barModel->model = model;

++                             barModel->barItem = &dataItem;

++                             barModel->coord = QPoint(int(dataRowIndex), col);

++                             barModel->texture = texture;

++

++                             if (!barList->contains(barModel))

++                                 barList->append(barModel);

++

++                             ++dataColIndex;

++                         }

++                         ++dataRowIndex;

++                     }

++                 }

++             } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                 Q_TRACE_SCOPE(QGraphs3DBarsGenerateBarsDefault);

++

++                 auto scene = graphNode();

++                 BarModel *barInstancing = new BarModel();

++                 barInstancing->texture = texture;

++

++                 if (barInstancing->instancing == nullptr) {

++                     barInstancing->instancing = new BarInstancing;

++                     barInstancing->instancing->setParent(barSeries);

++                     barInstancing->selectionInstancing = new BarInstancing;

++                     barInstancing->selectionInstancing->setParent(barSeries);

++                     barInstancing->multiSelectionInstancing = new BarInstancing;

++                     barInstancing->multiSelectionInstancing->setParent(barSeries);

++                 }

++

++                 if (barInstancing->model == nullptr) {

++                     barInstancing->model = createDataItem(scene, barSeries);

++                     barInstancing->model->setInstancing(barInstancing->instancing);

++                     barInstancing->model->setVisible(visible);

++                     barInstancing->model->setPickable(true);

++                     barInstancing->selectedModel = createDataItem(scene, barSeries);

++                     barInstancing->selectedModel->setInstancing(barInstancing->selectionInstancing);

++                     barInstancing->selectedModel->setVisible(visible);

++                     barInstancing->selectedModel->setPickable(true);

++                     barInstancing->multiSelectedModel = createDataItem(scene, barSeries);

++                     barInstancing->multiSelectedModel->setInstancing(

++                         barInstancing->multiSelectionInstancing);

++                     barInstancing->multiSelectedModel->setVisible(visible);

++                     barInstancing->multiSelectedModel->setPickable(true);

++                 }

++

++                 if (!barList->contains(barInstancing)) {

++                     barList->append(barInstancing);

++                     qCDebug(lcGraphs3D) << "bar info:"

++                         << "\n model:" << barInstancing->model

++                         << "\n series:" << barSeries

++                         << "\n textureSize:" << barInstancing->texture->textureData()->size()

++                         << "\n rowCount: " << barSeries->dataProxy()->rowCount()

++                         << "\n columnCount:" << barSeries->dataProxy()->colCount()

++                         << "\n baseColor" << barSeries->baseColor()

++                         << "\n mesh:" << barSeries->mesh();

++                 }

++             }

++

++             markSeriesVisualsDirty();

++         }

++

++         if (barSeries->isVisible())

++             m_visibleSeriesCount++;

++     }

++ }

++

++ QQuick3DModel *QQuickGraphsBars::createDataItem(QQuick3DNode *scene, QAbstract3DSeries *series)

++ {

++     auto model = new QQuick3DModel();

++     model->setParent(scene);

++     model->setParentItem(scene);

++     model->setObjectName(QStringLiteral("BarModel"));

++     QString fileName = getMeshFileName();

++     if (fileName.isEmpty())

++         fileName = series->userDefinedMesh();

++

++     model->setSource(QUrl(fileName));

++     return model;

++ }

++

++ QString QQuickGraphsBars::getMeshFileName()

++ {

++     QString fileName = {};

++     switch (m_meshType) {

++     case QAbstract3DSeries::Mesh::Sphere:

++         fileName = QStringLiteral("defaultMeshes/sphereMesh");

++         break;

++     case QAbstract3DSeries::Mesh::Bar:

++     case QAbstract3DSeries::Mesh::Cube:

++         fileName = QStringLiteral("defaultMeshes/barMesh");

++         break;

++     case QAbstract3DSeries::Mesh::Pyramid:

++         fileName = QStringLiteral("defaultMeshes/pyramidMesh");

++         break;

++     case QAbstract3DSeries::Mesh::Cone:

++         fileName = QStringLiteral("defaultMeshes/coneMesh");

++         break;

++     case QAbstract3DSeries::Mesh::Cylinder:

++         fileName = QStringLiteral("defaultMeshes/cylinderMesh");

++         break;

++     case QAbstract3DSeries::Mesh::BevelBar:

++     case QAbstract3DSeries::Mesh::BevelCube:

++         fileName = QStringLiteral("defaultMeshes/bevelBarMesh");

++         break;

++     case QAbstract3DSeries::Mesh::UserDefined:

++         break;

++     default:

++         fileName = QStringLiteral("defaultMeshes/sphereMesh");

++     }

++

++     fixMeshFileName(fileName, m_meshType);

++

++     return fileName;

++ }

++

++ void QQuickGraphsBars::fixMeshFileName(QString &fileName, QAbstract3DSeries::Mesh meshType)

++ {

++     // Should it be smooth?

++     if (m_smooth && meshType != QAbstract3DSeries::Mesh::Point

++         && meshType != QAbstract3DSeries::Mesh::UserDefined) {

++         fileName += QStringLiteral("Smooth");

++     }

++

++     // Should it be filled?

++     if (!theme()->isPlotAreaBackgroundVisible() && meshType != QAbstract3DSeries::Mesh::Sphere

++         && meshType != QAbstract3DSeries::Mesh::Point

++         && meshType != QAbstract3DSeries::Mesh::UserDefined) {

++         fileName.append(QStringLiteral("Full"));

++     }

++ }

++

++ void QQuickGraphsBars::updateBarVisuality(QBar3DSeries *series, int visualIndex)

++ {

++     QList<BarModel *> barList = *m_barModelsMap.value(series);

++     for (int i = 0; i < barList.count(); i++) {

++         barList.at(i)->visualIndex = visualIndex;

++         barList.at(i)->model->setVisible(series->isVisible());

++         if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++             barList.at(0)->selectedModel->setVisible(false);

++             barList.at(0)->multiSelectedModel->setVisible(false);

++         }

++     }

++

++     m_changeTracker.selectedBarChanged = true;

++     itemLabel()->setVisible(false);

++ }

++

++ void QQuickGraphsBars::updateBarPositions(QBar3DSeries *series)

++ {

++     QBarDataProxy *dataProxy = series->dataProxy();

++

++     m_seriesScaleX = 1.0f / float(m_visibleSeriesCount);

++     m_seriesStep = 1.0f / float(m_visibleSeriesCount);

++     m_seriesStart = -((float(m_visibleSeriesCount) - 1.0f) * 0.5f)

++                     * (m_seriesStep - (m_seriesStep * m_cachedBarSeriesMargin.width()));

++

++     if (m_keepSeriesUniform)

++         m_seriesScaleZ = m_seriesScaleX;

++     else

++         m_seriesScaleZ = 1.0f;

++

++     m_zeroPosition = valueAxis()->positionAt(m_actualFloorLevel);

++

++     QList<BarModel *> barList = *m_barModelsMap.value(series);

++

++     qsizetype dataRowIndex = m_minRow;

++     qsizetype newRowSize = qMin(dataProxy->rowCount() - dataRowIndex, m_newRows);

++     qsizetype row = 0;

++     qsizetype dataColIndex = m_minCol;

++     qsizetype newColSize = qMin(dataProxy->colCount() - dataColIndex, m_newCols);

++     qsizetype col = 0;

++     for (int i = 0; i < barList.count(); i++) {

++         float seriesPos = m_seriesStart + 0.5f

++                           + (m_seriesStep

++                              * (barList.at(i)->visualIndex

++                                 - (barList.at(i)->visualIndex * m_cachedBarSeriesMargin.width())));

++         if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++             Q_TRACE_SCOPE(QGraphs3DBarsUpdateBarPositionsLegacy);

++

++             QBarDataItem *item = barList.at(i)->barItem;

++             QQuick3DModel *model = barList.at(i)->model;

++             float heightValue = updateBarHeightParameters(item, series->valueAxis());

++             float angle = item->rotation();

++

++             if (angle) {

++                 model->setRotation(QQuaternion::fromAxisAndAngle(upVector, angle)

++                                    + series->meshRotation());

++             } else {

++                 model->setRotation(QQuaternion() + series->meshRotation());

++             }

++

++             if (heightValue < 0.f) {

++                 const QVector3D rot = model->eulerRotation();

++                 model->setEulerRotation(QVector3D(-180.f, rot.y(), rot.z()));

++             }

++

++             float colPos = (col + seriesPos) * m_cachedBarSpacing.width();

++             float xPos = (colPos - m_rowWidth) / m_scaleFactor;

++             float rowPos = (row + 0.5f) * (m_cachedBarSpacing.height());

++             float zPos = (m_columnDepth - rowPos) / m_scaleFactor;

++             float yPos;

++

++             if (heightValue < 0.f)

++                 yPos = heightValue - m_backgroundAdjustment - 0.015f;

++             else

++                 yPos = heightValue - m_backgroundAdjustment + 0.015f;

++

++             barList.at(i)->heightValue = heightValue;

++             model->setPosition(QVector3D(xPos, yPos, zPos));

++

++             if (heightValue == 0) {

++                 model->setScale(QVector3D(.0f, .0f, .0f));

++                 model->setPickable(false);

++             } else {

++                 model->setScale(QVector3D(m_xScale * m_seriesScaleX,

++                                           qAbs(heightValue),

++                                           m_zScale * m_seriesScaleZ));

++                 model->setPickable(true);

++             }

++

++             if (col < newColSize - 1) {

++                 ++col;

++             } else {

++                 col = 0;

++                 if (row < newRowSize - 1)

++                     ++row;

++                 else

++                     row = 0;

++             }

++         } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++             Q_TRACE_SCOPE(QGraphs3DBarsGenerateBarsDefault);

++

++             deleteBarItemHolders(barList.at(i)->instancing);

++             QList<BarItemHolder *> positions;

++             for (int row = 0; row < newRowSize; ++row) {

++                 const QBarDataRow &dataRow = dataProxy->rowAt(dataRowIndex);

++                 if (!dataRow.isEmpty()) {

++                     dataColIndex = m_minCol;

++                     newColSize = qMin(dataRow.size() - dataColIndex, m_newCols);

++                     for (int col = 0; col < newColSize; col++) {

++                         const QBarDataItem &item = dataRow.at(dataColIndex);

++                         float heightValue = updateBarHeightParameters(&item, series->valueAxis());

++                         BarItemHolder *bih = new BarItemHolder();

++

++                         if (barList.at(i)->model->eulerRotation() != QVector3D()

++                             || series->meshRotation() != QQuaternion()) {

++                             const QQuaternion rotation =

++                                 QQuaternion(barList.at(i)->model->eulerRotation().toVector4D())

++                                 + series->meshRotation();

++

++                             bih->rotation = rotation;

++                         } else {

++                             bih->rotation = QQuaternion::fromEulerAngles(

++                                 QVector3D(.0f, item.rotation(), .0f));

++                         }

++                         if (heightValue < 0.f) {

++                             // if bars need to be rendered negative(under the floor)

++                             // construct a temporary quaternion(normalized) that rotates through

++                             // angle (in degrees) around x axis and multiply rotation with it.

++                             QQuaternion  rot = QQuaternion::fromAxisAndAngle(1.0f, 0.0f, 0.0f, 180.0f);

++                             bih->rotation *= rot;

++                         }

++

++                         float colPos = (col + seriesPos) * m_cachedBarSpacing.width();

++                         float xPos = (colPos - m_rowWidth) / m_scaleFactor;

++                         float rowPos = (row + 0.5f) * (m_cachedBarSpacing.height());

++                         float zPos = (m_columnDepth - rowPos) / m_scaleFactor;

++                         float yPos;

++

++                         if (heightValue < 0.f)

++                             yPos = heightValue - m_backgroundAdjustment - 0.015f;

++                         else

++                             yPos = heightValue - m_backgroundAdjustment + 0.015f;

++

++                         bih->position = {xPos, yPos, zPos};

++                         bih->coord = QPoint(row, col);

++

++                         if (heightValue == 0) {

++                             bih->scale = {.0f, .0f, .0f};

++                         } else {

++                             bih->scale = {m_xScale * m_seriesScaleX,

++                                           qAbs(heightValue),

++                                           m_zScale * m_seriesScaleZ};

++                         }

++

++                         bih->heightValue = heightValue;

++                         bih->selectedBar = false;

++

++                         bool colorStyleIsUniform = (series->colorStyle()

++                                                     == QGraphsTheme::ColorStyle::Uniform);

++                         if (colorStyleIsUniform) {

++                             QList<QColor> rowColors = series->rowColors();

++                             if (rowColors.size() == 0) {

++                                 bih->color = series->baseColor();

++                             } else {

++                                 int rowColorIndex = bih->coord.x() % rowColors.size();

++                                 bih->color = rowColors[rowColorIndex];

++                             }

++                         }

++

++                         positions.push_back(bih);

++                         dataColIndex++;

++                     }

++                 }

++                 dataRowIndex++;

++             }

++             barList.at(i)->instancing->setDataArray(positions);

++         }

++     }

++ }

++

++ float QQuickGraphsBars::updateBarHeightParameters(const QBarDataItem *item, QValue3DAxis *axis)

++ {

++

++     if (!axis)

++         axis = valueAxis();

++     float value = item->value();

++     float heightValue = axis->positionAt(value);

++

++     if (qIsNaN(heightValue))

++         return 0.0f;

++

++     if (m_noZeroInRange) {

++         if (m_hasNegativeValues) {

++             heightValue = -1.0f + heightValue;

++             if (heightValue > 0.0f)

++                 heightValue = 0.0f;

++         } else {

++             if (heightValue < 0.0f)

++                 heightValue = 0.0f;

++         }

++     } else {

++         heightValue -= m_zeroPosition;

++     }

++

++     if (axis->reversed())

++         heightValue = -heightValue;

++

++     return heightValue;

++ }

++

++ void QQuickGraphsBars::updateBarVisuals(QBar3DSeries *series)

++ {

++     QList<BarModel *> barList = *m_barModelsMap.value(series);

++     bool useGradient = series->d_func()->isUsingGradient();

++

++     if (useGradient) {

++         if (!m_hasHighlightTexture) {

++             m_highlightTexture = createTexture();

++             m_highlightTexture->setParent(this);

++             m_multiHighlightTexture = createTexture();

++             m_multiHighlightTexture->setParent(this);

++             m_hasHighlightTexture = true;

++         }

++         auto highlightGradient = series->singleHighlightGradient();

++         auto highlightTextureData = static_cast<QQuickGraphsTextureData *>(

++             m_highlightTexture->textureData());

++         highlightTextureData->createGradient(highlightGradient);

++         auto multiHighlightGradient = series->multiHighlightGradient();

++         auto multiHighlightTextureData = static_cast<QQuickGraphsTextureData *>(

++             m_multiHighlightTexture->textureData());

++         multiHighlightTextureData->createGradient(multiHighlightGradient);

++     } else {

++         if (m_hasHighlightTexture) {

++             m_highlightTexture->deleteLater();

++             m_multiHighlightTexture->deleteLater();

++             m_hasHighlightTexture = false;

++         }

++     }

++

++     bool rangeGradient = (useGradient

++                           && series->d_func()->m_colorStyle == QGraphsTheme::ColorStyle::RangeGradient);

++     QColor baseColor = series->baseColor();

++     QColor barColor;

++     QLinearGradient gradient = series->baseGradient();

++

++     if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++         // Release resources that might not have been deleted even though deleteLater had been set

++

++         if (m_customView)

++             m_customView->window()->releaseResources();

++         else

++             window()->releaseResources();

++

++         for (int i = 0; i < barList.count(); i++) {

++             QQuick3DModel *model = barList.at(i)->model;

++             auto textureData = static_cast<QQuickGraphsTextureData *>(

++                 barList.at(i)->texture->textureData());

++             textureData->createGradient(series->baseGradient());

++             const bool transparency = textureData->hasTransparency();

++             updateItemMaterial(model,

++                                useGradient,

++                                rangeGradient,

++                                QStringLiteral(":/materials/BarsMaterial"));

++             if (useGradient) {

++                 updateMaterialProperties(model,

++                                          false,

++                                          false,

++                                          barList.at(i)->texture,

++                                          QColor(Qt::white),

++                                          transparency);

++             } else {

++                 QList<QColor> rowColors = series->rowColors();

++                 if (rowColors.size() == 0) {

++                     barColor = baseColor;

++                 } else {

++                     int rowColorIndex = barList.at(i)->coord.x() % rowColors.size();

++                     barColor = rowColors[rowColorIndex];

++                 }

++                 const bool transparency = barColor.alphaF() < 1.0;

++                 updateMaterialProperties(model,

++                                          false,

++                                          false,

++                                          barList.at(i)->texture,

++                                          barColor,

++                                          transparency);

++             }

++             QQmlListReference materialsRef(model, "materials");

++             auto customMaterial = qobject_cast<QQuick3DCustomMaterial *>(materialsRef.at(0));

++             customMaterial->setProperty("valueColoring", series->isValueColoringEnabled());

++             customMaterial->setProperty("heightValue", barList.at(i)->heightValue);

++             customMaterial->setProperty("shaded",

++                                         series->lightingMode()

++                                             == QAbstract3DSeries::LightingMode::Shaded);

++         }

++     } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++         for (int i = 0; i < barList.count(); i++) {

++             auto textureData = static_cast<QQuickGraphsTextureData *>(

++                 barList.at(i)->texture->textureData());

++             textureData->createGradient(series->baseGradient());

++             barList.at(i)->instancing->setTransparency(textureData->hasTransparency());

++             updateItemMaterial(barList.at(i)->model,

++                                useGradient,

++                                rangeGradient,

++                                QStringLiteral(":/materials/BarsMaterialInstancing"));

++             if (useGradient) {

++                 updateMaterialProperties(barList.at(i)->model,

++                                          false,

++                                          false,

++                                          barList.at(i)->texture,

++                                          QColor(Qt::white),

++                                          textureData->hasTransparency());

++             } else {

++                 if (!barList.at(i)->instancing->dataArray().isEmpty()) {

++                     const bool transparency

++                         = barList.at(i)->instancing->dataArray().at(0)->color.alphaF() < 1.0;

++                     updateMaterialProperties(barList.at(i)->model,

++                                              false,

++                                              false,

++                                              barList.at(i)->texture,

++                                              QColor(Qt::white),

++                                              transparency);

++                 }

++             }

++             QQmlListReference materialsRef(barList.at(i)->model, "materials");

++             auto customMaterial = qobject_cast<QQuick3DCustomMaterial *>(materialsRef.at(0));

++             customMaterial->setProperty("valueColoring", series->isValueColoringEnabled());

++             customMaterial->setProperty("rootScale", rootNode()->scale().y());

++             customMaterial->setProperty("shaded",

++                                         series->lightingMode()

++                                             == QAbstract3DSeries::LightingMode::Shaded);

++         }

++     }

++ }

++

++ void QQuickGraphsBars::updateItemMaterial(QQuick3DModel *item,

++                                           bool useGradient,

++                                           bool rangeGradient,

++                                           const QString &materialName)

++ {

++     QQmlListReference materialsRef(item, "materials");

++

++     bool needNewMaterial = false;

++     if (!materialsRef.size())

++         needNewMaterial = true;

++     else if (materialsRef.at(0)->objectName().contains(QStringLiteral("Instancing"))

++              == materialName.contains(QStringLiteral("Instancing"))) {

++         needNewMaterial = true;

++     }

++

++     if (needNewMaterial) {

++         materialsRef.clear();

++         auto *material = createQmlCustomMaterial(materialName);

++         material->setObjectName(materialName);

++         material->setParent(item);

++         materialsRef.append(material);

++     }

++     int colorStyle;

++     if (!useGradient)

++         colorStyle = 0; // style is uniform

++     else if (!rangeGradient)

++         colorStyle = 1; // style is objectGradient

++     else

++         colorStyle = 2; // style is rangeGradient

++

++     auto *material = qobject_cast<QQuick3DCustomMaterial *>(materialsRef.at(0));

++     material->setProperty("colorStyle", colorStyle);

++ }

++

++ void QQuickGraphsBars::updateMaterialProperties(QQuick3DModel *item,

++                                                 const bool isHighlight,

++                                                 const bool isMultiHighlight,

++                                                 QQuick3DTexture *texture,

++                                                 QColor color,

++                                                 const bool transparency)

++ {

++     QQmlListReference materialsRef(item, "materials");

++     auto customMaterial = qobject_cast<QQuick3DCustomMaterial *>(materialsRef.at(0));

++     if (!customMaterial)

++         return;

++     customMaterial->setProperty("transparency", transparency);

++     QVariant textureInputAsVariant = customMaterial->property("custex");

++     QQuick3DShaderUtilsTextureInput *textureInput = textureInputAsVariant

++                                                         .value<QQuick3DShaderUtilsTextureInput *>();

++

++     int colorStyle = customMaterial->property("colorStyle").value<int>();

++     if (colorStyle == 0) {

++         customMaterial->setProperty("uniformColor", color);

++     } else {

++         if (!isHighlight && !isMultiHighlight)

++             textureInput->setTexture(texture);

++         else

++             textureInput->setTexture(isHighlight ? m_highlightTexture : m_multiHighlightTexture);

++         customMaterial->setProperty("isHighlight", isHighlight || isMultiHighlight);

++     }

++     customMaterial->setProperty("specularBrightness", lightStrength() * 0.05);

++     customMaterial->setProperty("rootScale", rootNode()->scale().y());

++ }

++

++ void QQuickGraphsBars::removeBarModels()

++ {

++     for (const auto list : std::as_const(m_barModelsMap)) {

++         for (auto barModel : std::as_const(*list)) {

++             deleteBarModels(barModel->model);

++             if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                 deleteBarItemHolders(barModel->instancing);

++                 deleteBarItemHolders(barModel->selectionInstancing);

++                 deleteBarItemHolders(barModel->multiSelectionInstancing);

++                 deleteBarModels(barModel->selectedModel);

++                 deleteBarModels(barModel->multiSelectedModel);

++             }

++             delete barModel;

++         }

++         delete list;

++     }

++

++     m_barModelsMap.clear();

++     setSelectedBar(m_selectedBar, m_selectedBarSeries, false);

++ }

++

++ void QQuickGraphsBars::deleteBarModels(QQuick3DModel *model)

++ {

++     if (model) {

++         model->setPickable(false);

++         model->setVisible(false);

++         QQmlListReference materialsRef(model, "materials");

++         if (materialsRef.size()) {

++             auto material = materialsRef.at(0);

++             delete material;

++         }

++         delete model;

++     }

++ }

++

++ void QQuickGraphsBars::deleteBarItemHolders(BarInstancing *instancing)

++ {

++     if (instancing) {

++         const QList<BarItemHolder *> barItemList = instancing->dataArray();

++         for (const auto bih : barItemList)

++             delete bih;

++         instancing->clearDataArray();

++     }

++ }

++

++ QQuick3DTexture *QQuickGraphsBars::createTexture()

++ {

++     QQuick3DTexture *texture = new QQuick3DTexture();

++     texture->setParent(this);

++     texture->setRotationUV(-90.0f);

++     texture->setHorizontalTiling(QQuick3DTexture::ClampToEdge);

++     texture->setVerticalTiling(QQuick3DTexture::ClampToEdge);

++     QQuickGraphsTextureData *textureData = new QQuickGraphsTextureData();

++     textureData->setParent(texture);

++     textureData->setParentItem(texture);

++     texture->setTextureData(textureData);

++

++     return texture;

++ }

++

++ bool QQuickGraphsBars::doPicking(QPointF position)

++ {

++     if (!QQuickGraphsItem::doPicking(position))

++         return false;

++

++     Q_TRACE_SCOPE(QGraphs3DBarsDoPicking, position.x(), position.y());

++

++     m_selectionDirty = true;

++     QList<QQuick3DPickResult> pickResults;

++     if (m_customView)

++         pickResults = m_customView->pickAll(position.x(), position.y());

++     else

++         pickResults = pickAll(position.x(), position.y());

++     QQuick3DModel *selectedModel = nullptr;

++     QVector3D instancePos = {.0f, .0f, .0f};

++     if (!selectionMode().testFlag(QtGraphs3D::SelectionFlag::None)) {

++         if (!pickResults.isEmpty()) {

++             for (const auto &picked : std::as_const(pickResults)) {

++                 if (const auto &hit = picked.objectHit()) {

++                     if (hit == backgroundBB() || hit == background()) {

++                         resetClickedStatus();

++                         continue;

++                     } else if (hit->objectName().contains(QStringLiteral("BarModel"))) {

++                         if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++                             selectedModel = hit;

++                             for (const auto barlist : std::as_const(m_barModelsMap)) {

++                                 for (const auto barModel : std::as_const(*barlist)) {

++                                     if (barModel->model == selectedModel) {

++                                         setSelectedBar(barModel->coord,

++                                                        m_barModelsMap.key(barlist),

++                                                        false);

++                                     }

++                                 }

++                             }

++                             break;

++                         } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                             BarInstancing *barIns = static_cast<BarInstancing *>(hit->instancing());

++                             // Prevents to select bars with a height of 0 which affect picking.

++                             if (!barIns->dataArray().isEmpty()

++                                 && barIns->dataArray().at(picked.instanceIndex())->heightValue

++                                        != 0) {

++                                 selectedModel = hit;

++                                 instancePos = selectedModel->instancing()->instancePosition(

++                                     picked.instanceIndex());

++                                 for (const auto barlist : std::as_const(m_barModelsMap)) {

++                                     for (const auto barModel : std::as_const(*barlist)) {

++                                         QList<BarItemHolder *> barItemList = barModel->instancing

++                                                                                  ->dataArray();

++                                         for (const auto bih : std::as_const(barItemList)) {

++                                             if (bih->position == instancePos) {

++                                                 setSelectedBar(bih->coord,

++                                                                m_barModelsMap.key(barlist),

++                                                                false);

++                                                 qCDebug(lcInput3D) << "picking result:"

++                                                     << "\n instance position:" << bih->position

++                                                     << "\n picked item column and row position:"

++                                                     << bih->coord

++                                                     << "\n picked item value:"

++                                                     << m_barModelsMap.key(barlist)->dataProxy()

++                                                                    ->itemAt(bih->coord).value();

++                                                 if (isSliceEnabled())

++                                                     setSliceActivatedChanged(true);

++                                             }

++                                         }

++                                     }

++                                 }

++                                 break;

++                             }

++                         }

++                     } else if (hit->objectName().contains(QStringLiteral("ElementAxis"))) {

++                         QPoint coord = invalidSelectionPosition();

++                         if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Column)

++                             && selectedAxis() == axisX()) {

++                             // Use row from previous selection in case of row + column mode

++                             int previousRow = qMax(0, m_selectedBar.x());

++                             coord = QPoint(previousRow, selectedLabelIndex());

++                         } else if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row)

++                                    && selectedAxis() == axisZ()) {

++                             // Use column from previous selection in case of row + column mode

++                             int previousCol = qMax(0, m_selectedBar.y());

++                             coord = QPoint(selectedLabelIndex(), previousCol);

++                         }

++                         for (auto it = m_barModelsMap.begin(); it != m_barModelsMap.end(); it++) {

++                             if (it.key()->isVisible())

++                                 setSelectedBar(coord, it.key(), false);

++                         }

++                         break;

++                     }

++                 }

++             }

++         } else {

++             resetClickedStatus();

++         }

++     }

++     return true;

++ }

++

++ bool QQuickGraphsBars::doRayPicking(QVector3D origin, QVector3D direction)

++ {

++     if (!QQuickGraphsItem::doRayPicking(origin, direction))

++         return false;

++

++     Q_TRACE_SCOPE(QGraphs3DBarsDoRayPicking, origin.x(), origin.y(), origin.z(), direction.x(),

++             direction.y(), direction.z());

++

++     m_selectionDirty = true;

++     QList<QQuick3DPickResult> pickResults;

++     if (m_customView)

++         pickResults = m_customView->rayPickAll(origin, direction);

++     else

++         pickResults = rayPickAll(origin, direction);

++     QQuick3DModel *selectedModel = nullptr;

++     QVector3D instancePos = {.0f, .0f, .0f};

++     if (!selectionMode().testFlag(QtGraphs3D::SelectionFlag::None)) {

++         if (!pickResults.isEmpty()) {

++             for (const auto &picked : std::as_const(pickResults)) {

++                 if (const auto &hit = picked.objectHit()) {

++                     if (hit == backgroundBB() || hit == background()) {

++                         resetClickedStatus();

++                         continue;

++                     } else if (hit->objectName().contains(QStringLiteral("BarModel"))) {

++                         if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++                             selectedModel = hit;

++                             for (const auto barlist : std::as_const(m_barModelsMap)) {

++                                 for (const auto barModel : std::as_const(*barlist)) {

++                                     if (barModel->model == selectedModel) {

++                                         setSelectedBar(barModel->coord,

++                                                        m_barModelsMap.key(barlist),

++                                                        false);

++                                     }

++                                 }

++                             }

++                             break;

++                         } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                             BarInstancing *barIns = static_cast<BarInstancing *>(hit->instancing());

++                             // Prevents to select bars with a height of 0 which affect picking.

++                             if (!barIns->dataArray().isEmpty()

++                                 && barIns->dataArray().at(picked.instanceIndex())->heightValue

++                                        != 0) {

++                                 selectedModel = hit;

++                                 instancePos = selectedModel->instancing()->instancePosition(

++                                     picked.instanceIndex());

++                                 for (const auto barlist : std::as_const(m_barModelsMap)) {

++                                     for (const auto barModel : std::as_const(*barlist)) {

++                                         QList<BarItemHolder *> barItemList = barModel->instancing

++                                                                                  ->dataArray();

++                                         for (const auto bih : std::as_const(barItemList)) {

++                                             if (bih->position == instancePos) {

++                                                 setSelectedBar(bih->coord,

++                                                                m_barModelsMap.key(barlist),

++                                                                false);

++                                                 qCDebug(lcInput3D) << "picking result:"

++                                                     << "\n instance position:" << bih->position

++                                                     << "\n picked item column and row position:"

++                                                     << bih->coord

++                                                     << "\n picked item value:"

++                                                     << m_barModelsMap.key(barlist)->dataProxy()

++                                                                    ->itemAt(bih->coord).value();

++                                                 if (isSliceEnabled())

++                                                     setSliceActivatedChanged(true);

++                                             }

++                                         }

++                                     }

++                                 }

++                                 break;

++                             }

++                         }

++                     } else if (hit->objectName().contains(QStringLiteral("ElementAxis"))) {

++                         QPoint coord = invalidSelectionPosition();

++                         if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Column)

++                             && selectedAxis() == axisX()) {

++                             // Use row from previous selection in case of row + column mode

++                             int previousRow = qMax(0, m_selectedBar.x());

++                             coord = QPoint(previousRow, selectedLabelIndex());

++                         } else if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row)

++                                    && selectedAxis() == axisZ()) {

++                             // Use column from previous selection in case of row + column mode

++                             int previousCol = qMax(0, m_selectedBar.y());

++                             coord = QPoint(selectedLabelIndex(), previousCol);

++                         }

++                         for (auto it = m_barModelsMap.begin(); it != m_barModelsMap.end(); it++) {

++                             if (it.key()->isVisible())

++                                 setSelectedBar(coord, it.key(), false);

++                         }

++                         break;

++                     }

++                 }

++             }

++         } else {

++             resetClickedStatus();

++         }

++     }

++     return true;

++ }

++

++ QAbstract3DAxis *QQuickGraphsBars::createDefaultAxis(QAbstract3DAxis::AxisOrientation orientation)

++ {

++     QAbstract3DAxis *defaultAxis = 0;

++

++     if (orientation == QAbstract3DAxis::AxisOrientation::Y)

++         defaultAxis = createDefaultValueAxis();

++     else

++         defaultAxis = createDefaultCategoryAxis();

++

++     return defaultAxis;

++ }

++

++ void QQuickGraphsBars::adjustSelectionPosition(QPoint &pos, const QBar3DSeries *series)

++ {

++     const QBarDataProxy *proxy = 0;

++     if (series)

++         proxy = series->dataProxy();

++

++     if (!proxy)

++         pos = invalidSelectionPosition();

++

++     if (pos != invalidSelectionPosition()) {

++         qsizetype maxRow = proxy->rowCount() - 1;

++         qsizetype maxCol = (pos.x() <= maxRow && pos.x() >= 0 && !proxy->rowAt(pos.x()).isEmpty())

++                 ? proxy->rowAt(pos.x()).size() - 1

++                 : -1;

++

++         if (pos.x() < 0 || pos.x() > maxRow || pos.y() < 0 || pos.y() > maxCol)

++             pos = invalidSelectionPosition();

++     }

++ }

++

++ void QQuickGraphsBars::setSelectedBar(QPoint coord, QBar3DSeries *series, bool enterSlice)

++ {

++     // If the selection targets non-existent bar, clear selection instead.

++     QPoint pos = coord;

++

++     // Series may already have been removed, so check it before setting the

++     // selection.

++     if (!m_seriesList.contains(series))

++         series = nullptr;

++

++     adjustSelectionPosition(pos, series);

++

++     if (series && selectionMode().testFlag(QtGraphs3D::SelectionFlag::Slice)) {

++         // If the selected bar is outside data window, or there is no visible

++         // selected bar, disable slicing.

++         if (pos.x() < m_axisZ->min() || pos.x() > m_axisZ->max() || pos.y() < m_axisX->min()

++             || pos.y() > m_axisX->max() || !series->isVisible()) {

++             scene()->setSlicingActive(false);

++         } else if (enterSlice) {

++             scene()->setSlicingActive(true);

++         }

++         emitNeedRender();

++     }

++

++     if (pos != m_selectedBar || series != m_selectedBarSeries) {

++         bool seriesChanged = (series != m_selectedBarSeries);

++         m_selectedBar = pos;

++         m_selectedBarSeries = series;

++         m_changeTracker.selectedBarChanged = true;

++         checkSliceEnabled();

++

++         // Clear selection from other series and finally set new selection to the

++         // specified series

++         for (QAbstract3DSeries *otherSeries : std::as_const(m_seriesList)) {

++             QBar3DSeries *barSeries = static_cast<QBar3DSeries *>(otherSeries);

++             if (barSeries != m_selectedBarSeries)

++                 barSeries->d_func()->setSelectedBar(invalidSelectionPosition());

++         }

++         if (m_selectedBarSeries)

++             m_selectedBarSeries->d_func()->setSelectedBar(m_selectedBar);

++

++         if (seriesChanged)

++             emit selectedSeriesChanged(m_selectedBarSeries);

++

++         if (pos == invalidSelectionPosition())

++             resetClickedStatus();

++

++         setSeriesVisualsDirty(true);

++         emitNeedRender();

++     }

++ }

++

++ void QQuickGraphsBars::updateSelectedBar()

++ {

++     for (auto it = m_barModelsMap.begin(); it != m_barModelsMap.end(); it++) {

++         if (m_selectedBarSeries && it.key()->isVisible()) {

++             if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++                 for (auto barList : std::as_const(*it.value())) {

++                     QQuickGraphsBars::SelectionType selectionType = isSelected(barList->coord.x(),

++                                                                                barList->coord.y(),

++                                                                                it.key());

++                     switch (selectionType) {

++                     case QQuickGraphsBars::SelectionItem: {

++                         updateMaterialProperties(barList->model,

++                                                  true,

++                                                  false,

++                                                  barList->texture,

++                                                  it.key()->singleHighlightColor());

++

++                         m_selectedBarPos = barList->model->position();

++                         QString label = (m_selectedBarSeries->d_func()->itemLabel());

++

++                         if (barList->heightValue >= 0.0f) {

++                             m_selectedBarPos.setY(m_selectedBarPos.y() + barList->heightValue

++                                                   + 0.2f);

++                         } else {

++                             m_selectedBarPos.setY(m_selectedBarPos.y() + barList->heightValue

++                                                   - 0.2f);

++                         }

++

++                         updateItemLabel(m_selectedBarPos);

++                         itemLabel()->setVisible(m_selectedBarSeries->isItemLabelVisible()

++                                                 && theme()->labelsVisible());

++                         itemLabel()->setProperty("labelText", label);

++                         if (!label.compare(QString(hiddenLabelTag)))

++                             itemLabel()->setVisible(false);

++                         if (isSliceEnabled())

++                             updateSliceItemLabel(label, m_selectedBarPos);

++                         break;

++                     }

++                     case QQuickGraphsBars::SelectionRow:

++                     case QQuickGraphsBars::SelectionColumn: {

++                         updateMaterialProperties(barList->model,

++                                                  false,

++                                                  true,

++                                                  barList->texture,

++                                                  it.key()->multiHighlightColor());

++                         break;

++                     }

++                     default:

++                         break;

++                     }

++                 }

++             } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                 QList<BarModel *> barList = *m_barModelsMap.value(it.key());

++                 deleteBarItemHolders(barList.at(0)->selectionInstancing);

++                 deleteBarItemHolders(barList.at(0)->multiSelectionInstancing);

++                 createBarItemHolders(it.key(), barList, false);

++             }

++         }

++     }

++ }

++

++ QQuickGraphsBars::SelectionType QQuickGraphsBars::isSelected(int row, int bar, QBar3DSeries *series)

++ {

++     QQuickGraphsBars::SelectionType isSelectedType = QQuickGraphsBars::SelectionNone;

++     if ((selectionMode().testFlag(QtGraphs3D::SelectionFlag::MultiSeries) && m_selectedBarSeries)

++         || series == m_selectedBarSeries) {

++         if (row == m_selectedBar.x() && bar == m_selectedBar.y()

++             && (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Item))) {

++             isSelectedType = QQuickGraphsBars::SelectionItem;

++         } else if (row == m_selectedBar.x()

++                    && (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row))) {

++             isSelectedType = QQuickGraphsBars::SelectionRow;

++         } else if (bar == m_selectedBar.y()

++                    && (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Column))) {

++             isSelectedType = QQuickGraphsBars::SelectionColumn;

++         }

++     }

++

++     return isSelectedType;

++ }

++

++ void QQuickGraphsBars::updateSliceItemLabel(const QString &label, QVector3D position)

++ {

++     QQuickGraphsItem::updateSliceItemLabel(label, position);

++

++     QFontMetrics fm(theme()->labelFont());

++     float textPadding = theme()->labelFont().pointSizeF() * .7f;

++     float labelHeight = fm.height() + textPadding;

++     float labelWidth = fm.horizontalAdvance(label) + textPadding;

++     sliceItemLabel()->setProperty("labelWidth", labelWidth);

++     sliceItemLabel()->setProperty("labelHeight", labelHeight);

++     QVector3D slicePos = position;

++     if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Column))

++         slicePos.setX(slicePos.z());

++     else if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row))

++         slicePos.setX(slicePos.x());

++     QValue3DAxis *valueAxis = static_cast<QValue3DAxis *>(axisY());

++     if (valueAxis->reversed())

++         slicePos.setY(slicePos.y() - (textPadding * .06f));

++     else

++         slicePos.setY(slicePos.y() + (textPadding * .06f));

++     slicePos.setZ(.1f);

++     sliceItemLabel()->setPosition(slicePos);

++     sliceItemLabel()->setProperty("labelText", label);

++     if (!label.compare(QString(hiddenLabelTag)))

++         sliceItemLabel()->setVisible(false);

++     sliceItemLabel()->setEulerRotation(QVector3D(0.0f, 0.0f, 90.0f));

++     sliceItemLabel()->setVisible(m_selectedBarSeries->isItemLabelVisible()

++                                  && theme()->labelsVisible());

++ }

++

++ void QQuickGraphsBars::resetClickedStatus()

++ {

++     m_selectedBarPos = QVector3D(0.0f, 0.0f, 0.0f);

++     m_selectedBar = QQuickGraphsBars::invalidSelectionPosition();

++     m_selectedBarSeries = 0;

++     clearSelection();

++

++     if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++         for (const auto barList : std::as_const(m_barModelsMap)) {

++             QList<BarItemHolder *> barItemList = barList->at(0)->instancing->dataArray();

++             for (auto bih : std::as_const(barItemList))

++                 bih->selectedBar = false;

++         }

++     }

++

++     if (sliceView() && sliceView()->isVisible()) {

++         setSliceActivatedChanged(true);

++         m_selectionDirty = true;

++     }

++     setSeriesVisualsDirty(true);

++ }

++

++ void QQuickGraphsBars::createSliceView()

++ {

++     setSliceOrthoProjection(false);

++     QQuickGraphsItem::createSliceView();

++

++     Q_TRACE_SCOPE(QGraphs3DBarsCreateSliceView);

++

++     QList<QBar3DSeries *> barSeries = barSeriesList();

++     for (const auto &barSeries : std::as_const(barSeries)) {

++         QList<BarModel *> &slicedBarList = m_slicedBarModels[barSeries];

++

++         if (slicedBarList.isEmpty()) {

++             if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++                 qsizetype dataRowIndex = m_minRow;

++                 qsizetype newRowSize = qMin(barSeries->dataProxy()->rowCount() - dataRowIndex,

++                                             m_newRows);

++                 qsizetype newColSize = 0;

++                 if (newRowSize) {

++                     const QBarDataRow *dataRow = &barSeries->dataProxy()->rowAt(dataRowIndex);

++                     if (dataRow) {

++                         qsizetype dataColIndex = m_minCol;

++                         newColSize = qMin(dataRow->size() - dataColIndex, m_newCols);

++                     }

++                 }

++                 qsizetype slicedBarListSize = 0;

++

++                 if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row))

++                     slicedBarListSize = newColSize;

++                 else if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Column))

++                     slicedBarListSize = newRowSize;

++

++                 for (int ind = 0; ind < slicedBarListSize; ++ind) {

++                     QQuick3DModel *model = createDataItem(sliceView()->scene(), barSeries);

++                     model->setVisible(false);

++                     BarModel *barModel = new BarModel();

++                     barModel->model = model;

++

++                     if (!slicedBarList.contains(barModel))

++                         slicedBarList.append(barModel);

++                 }

++             } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                 BarModel *barInstancing = new BarModel();

++

++                 if (barInstancing->selectionInstancing == nullptr) {

++                     barInstancing->selectionInstancing = new BarInstancing;

++                     barInstancing->selectionInstancing->setParent(barSeries);

++                     barInstancing->multiSelectionInstancing = new BarInstancing;

++                     barInstancing->multiSelectionInstancing->setParent(barSeries);

++                 }

++

++                 if (barInstancing->selectedModel == nullptr) {

++                     barInstancing->selectedModel = createDataItem(sliceView()->scene(), barSeries);

++                     barInstancing->selectedModel->setInstancing(barInstancing->selectionInstancing);

++                     barInstancing->selectedModel->setVisible(false);

++                     barInstancing->multiSelectedModel = createDataItem(sliceView()->scene(),

++                                                                        barSeries);

++                     barInstancing->multiSelectedModel->setInstancing(

++                         barInstancing->multiSelectionInstancing);

++                     barInstancing->multiSelectedModel->setVisible(false);

++                 }

++

++                 if (!slicedBarList.contains(barInstancing))

++                     slicedBarList.append(barInstancing);

++             }

++         }

++     }

++ }

++

++ void QQuickGraphsBars::toggleSliceGraph()

++ {

++     if (m_selectionDirty)

++         QQuickGraphsItem::toggleSliceGraph();

++

++     if (sliceView() && !sliceView()->isVisible()) {

++         removeSlicedBarModels();

++         m_changeTracker.selectedBarChanged = false;

++         return;

++     }

++

++     qsizetype index = 0;

++     bool rowMode = selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row);

++     for (auto it = m_slicedBarModels.begin(); it != m_slicedBarModels.end(); it++) {

++         bool useGradient = it.key()->d_func()->isUsingGradient();

++         bool rangeGradient = (useGradient

++                               && it.key()->d_func()->m_colorStyle

++                                       == QGraphsTheme::ColorStyle::RangeGradient);

++         QList<BarModel *> barList = *m_barModelsMap.value(it.key());

++         QList<BarModel *> sliceList = it.value();

++         if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++             for (int ind = 0; ind < it.value().count(); ++ind) {

++                 if (rowMode)

++                     index = (m_selectedBar.x() * it.key()->dataProxy()->colCount()) + ind;

++                 else

++                     index = m_selectedBar.y() + (ind * it.key()->dataProxy()->colCount());

++                 bool visible = ((m_selectedBarSeries == it.key()

++                                  || selectionMode().testFlag(QtGraphs3D::SelectionFlag::MultiSeries))

++                                 && it.key()->isVisible());

++                 if (index < barList.size() && m_selectedBar != invalidSelectionPosition()) {

++                     BarModel *sliceBarModel = sliceList.at(ind);

++                     BarModel *barModel = barList.at(index);

++

++                     sliceBarModel->model->setVisible(visible);

++                     if (rowMode) {

++                         sliceBarModel->model->setPosition(

++                             QVector3D(barModel->model->x(), barModel->model->y(), 0.0f));

++                     } else {

++                         sliceBarModel->model->setX(barModel->model->z()

++                                                    - (barList.at(0)->visualIndex * .1f));

++                         sliceBarModel->model->setY(barModel->model->y());

++                         sliceBarModel->model->setZ(0.0f);

++                     }

++                     sliceBarModel->model->setScale(barModel->model->scale());

++

++                     updateItemMaterial(sliceBarModel->model,

++                                        useGradient,

++                                        rangeGradient,

++                                        QStringLiteral(":/materials/BarsMaterial"));

++

++                     if (barModel->coord == m_selectedBar

++                         && selectionMode().testFlag(QtGraphs3D::SelectionFlag::Item)) {

++                         updateMaterialProperties(sliceBarModel->model,

++                                                  true,

++                                                  false,

++                                                  barList.at(index)->texture,

++                                                  it.key()->singleHighlightColor());

++                         updateSliceItemLabel(m_selectedBarSeries->itemLabel(), m_selectedBarPos);

++                     } else {

++                         updateMaterialProperties(sliceBarModel->model,

++                                                  false,

++                                                  false,

++                                                  barList.at(index)->texture,

++                                                  it.key()->baseColor());

++                     }

++                 } else {

++                     setSliceActivatedChanged(true);

++                     QQuickGraphsItem::toggleSliceGraph();

++                     setSliceEnabled(false);

++                     return;

++                 }

++             }

++             setSliceActivatedChanged(false);

++         } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++             deleteBarItemHolders(sliceList.at(0)->selectionInstancing);

++             deleteBarItemHolders(sliceList.at(0)->multiSelectionInstancing);

++             createBarItemHolders(it.key(), barList, true);

++             setSliceActivatedChanged(false);

++         }

++     }

++ }

++

++ void QQuickGraphsBars::handleLabelCountChanged(QQuick3DRepeater *repeater, QColor axisLabelColor)

++ {

++     QQuickGraphsItem::handleLabelCountChanged(repeater, axisLabelColor);

++

++     if (repeater == repeaterX())

++         handleDataColumnLabelsChanged();

++     if (repeater == repeaterZ())

++         handleDataRowLabelsChanged();

++ }

++

++ void QQuickGraphsBars::removeSlicedBarModels()

++ {

++     for (auto &list : std::as_const(m_slicedBarModels)) {

++         for (auto barModel : list) {

++             if (optimizationHint() == QtGraphs3D::OptimizationHint::Legacy) {

++                 deleteBarModels(barModel->model);

++             } else if (optimizationHint() == QtGraphs3D::OptimizationHint::Default) {

++                 deleteBarItemHolders(barModel->selectionInstancing);

++                 deleteBarItemHolders(barModel->multiSelectionInstancing);

++                 deleteBarModels(barModel->selectedModel);

++                 deleteBarModels(barModel->multiSelectedModel);

++             }

++             delete barModel;

++         }

++     }

++

++     m_slicedBarModels.clear();

++ }

++

++ void QQuickGraphsBars::createBarItemHolders(QBar3DSeries *series,

++                                             QList<BarModel *> barList,

++                                             bool slice)

++ {

++     bool useGradient = series->d_func()->isUsingGradient();

++     bool rangeGradient = (useGradient

++                           && series->d_func()->m_colorStyle == QGraphsTheme::ColorStyle::RangeGradient);

++     bool visible = ((m_selectedBarSeries == series

++                      || selectionMode().testFlag(QtGraphs3D::SelectionFlag::MultiSeries))

++                     && series->isVisible());

++     QList<BarItemHolder *> barItemList;

++     QList<BarItemHolder *> multiBarItemList;

++     QQuick3DModel *selectedModel = nullptr;

++     QQuick3DModel *multiSelectedModel = nullptr;

++     QList<BarItemHolder *> selectedItem;

++     QList<BarItemHolder *> multiSelectedItems;

++     BarInstancing *instancing;

++     BarInstancing *multiInstancing;

++

++     if (slice) {

++         QList<BarModel *> sliceBarList = m_slicedBarModels.value(series);

++         barItemList = barList.at(0)->selectionInstancing->dataArray();

++         multiBarItemList = barList.at(0)->multiSelectionInstancing->dataArray();

++         selectedModel = sliceBarList.at(0)->selectedModel;

++         multiSelectedModel = sliceBarList.at(0)->multiSelectedModel;

++         instancing = sliceBarList.at(0)->selectionInstancing;

++         multiInstancing = sliceBarList.at(0)->multiSelectionInstancing;

++     } else {

++         barItemList = barList.at(0)->instancing->dataArray();

++         selectedModel = barList.at(0)->selectedModel;

++         multiSelectedModel = barList.at(0)->multiSelectedModel;

++         instancing = barList.at(0)->selectionInstancing;

++         multiInstancing = barList.at(0)->multiSelectionInstancing;

++     }

++

++     for (const auto bih : std::as_const(barItemList)) {

++         QQuickGraphsBars::SelectionType selectionType = isSelected(bih->coord.x(),

++                                                                    bih->coord.y(),

++                                                                    series);

++         switch (selectionType) {

++         case QQuickGraphsBars::SelectionItem: {

++             updateItemMaterial(selectedModel,

++                                useGradient,

++                                rangeGradient,

++                                QStringLiteral(":/materials/BarsMaterialInstancing"));

++             updateMaterialProperties(selectedModel,

++                                      true,

++                                      false,

++                                      barList.at(0)->texture,

++                                      QColor(Qt::white));

++             if (!slice)

++                 bih->selectedBar = true;

++             selectedModel->setVisible(visible);

++             BarItemHolder *selectedBih = new BarItemHolder();

++             selectedBih->selectedBar = false;

++             selectedBih->color = series->singleHighlightColor();

++             selectedBih->coord = bih->coord;

++             selectedBih->rotation = bih->rotation;

++             selectedBih->heightValue = bih->heightValue;

++             selectedBih->position = bih->position;

++             selectedBih->scale = bih->scale;

++

++             QString label = m_selectedBarSeries->itemLabel();

++             if (slice) {

++                 if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row)) {

++                     selectedBih->position.setZ(.0f);

++                 } else {

++                     selectedBih->position.setX(selectedBih->position.z()

++                                                - (barList.at(0)->visualIndex * .1f));

++                     selectedBih->position.setZ(.0f);

++                 }

++                 updateSliceItemLabel(label, m_selectedBarPos);

++             }

++

++             selectedItem.push_back(selectedBih);

++             instancing->setDataArray(selectedItem);

++

++             m_selectedBarPos = bih->position;

++

++             if (bih->heightValue >= 0.0f)

++                 m_selectedBarPos.setY(m_selectedBarPos.y() + bih->heightValue + 0.2f);

++             else

++                 m_selectedBarPos.setY(m_selectedBarPos.y() + bih->heightValue - 0.2f);

++

++             updateItemLabel(m_selectedBarPos);

++             itemLabel()->setVisible(m_selectedBarSeries->isItemLabelVisible()

++                                     && theme()->labelsVisible());

++             itemLabel()->setProperty("labelText", label);

++             if (!label.compare(QString(hiddenLabelTag)))

++                 itemLabel()->setVisible(false);

++             if (isSliceEnabled())

++                 updateSliceItemLabel(label, m_selectedBarPos);

++             break;

++         }

++         case QQuickGraphsBars::SelectionRow:

++         case QQuickGraphsBars::SelectionColumn: {

++             updateItemMaterial(multiSelectedModel,

++                                useGradient,

++                                rangeGradient,

++                                QStringLiteral(":/materials/BarsMaterialInstancing"));

++             updateMaterialProperties(multiSelectedModel,

++                                      false,

++                                      true,

++                                      barList.at(0)->texture,

++                                      QColor(Qt::white));

++             if (!slice)

++                 bih->selectedBar = true;

++             multiSelectedModel->setVisible(visible);

++             BarItemHolder *selectedBih = new BarItemHolder();

++             selectedBih->selectedBar = false;

++             selectedBih->color = series->multiHighlightColor();

++             selectedBih->coord = bih->coord;

++             selectedBih->rotation = bih->rotation;

++             selectedBih->heightValue = bih->heightValue;

++             selectedBih->position = bih->position;

++             selectedBih->scale = bih->scale;

++

++             multiSelectedItems.push_back(selectedBih);

++             multiInstancing->setDataArray(multiSelectedItems);

++             break;

++         }

++         default:

++             break;

++         }

++     }

++

++     if (slice) {

++         for (const auto bih : std::as_const(multiBarItemList)) {

++             updateItemMaterial(multiSelectedModel,

++                                useGradient,

++                                rangeGradient,

++                                QStringLiteral(":/materials/BarsMaterialInstancing"));

++             updateMaterialProperties(multiSelectedModel,

++                                      false,

++                                      false,

++                                      barList.at(0)->texture,

++                                      QColor(Qt::white));

++

++             multiSelectedModel->setVisible(visible);

++             BarItemHolder *selectedBih = new BarItemHolder();

++             selectedBih->selectedBar = false;

++             selectedBih->color = series->baseColor();

++             selectedBih->coord = bih->coord;

++             selectedBih->rotation = bih->rotation;

++             selectedBih->heightValue = bih->heightValue;

++             selectedBih->position = bih->position;

++             selectedBih->scale = bih->scale;

++

++             if (selectionMode().testFlag(QtGraphs3D::SelectionFlag::Row)) {

++                 selectedBih->position.setZ(.0f);

++             } else {

++                 selectedBih->position.setX(selectedBih->position.z()

++                                            - (barList.at(0)->visualIndex * .1f));

++                 selectedBih->position.setZ(.0f);

++             }

++

++             multiSelectedItems.push_back(selectedBih);

++             multiInstancing->setDataArray(multiSelectedItems);

++         }

++     }

++ }

++

++ void QQuickGraphsBars::updateSelectionMode(QtGraphs3D::SelectionFlags mode)

++ {

++     checkSliceEnabled();

++     if (!sliceView())

++         createSliceView();

++

++     bool validSlice = mode.testFlag(QtGraphs3D::SelectionFlag::Slice) && m_selectedBarSeries;

++     if (sliceView() && sliceView()->isVisible()) {

++         if (validSlice) {

++             removeSlicedBarModels();

++             createSliceView();

++             toggleSliceGraph();

++         } else {

++             m_selectionDirty = true;

++             setSliceActivatedChanged(true);

++         }

++     } else if (validSlice) {

++         m_selectionDirty = true;

++         setSliceActivatedChanged(true);

++     }

++

++     setSeriesVisualsDirty(true);

++     itemLabel()->setVisible(false);

++     if (sliceView() && !mode.testFlag(QtGraphs3D::SelectionFlag::Item))

++         sliceItemLabel()->setVisible(false);

++ }

++

++ void QQuickGraphsBars::updateBarSpecs(float thicknessRatio, QSizeF spacing, bool relative)

++ {

++     // Convert ratio to QSizeF, as we need it in that format for autoscaling

++     // calculations

++     m_cachedBarThickness.setWidth(1.0);

++     m_cachedBarThickness.setHeight(1.0f / thicknessRatio);

++

++     if (relative) {

++         m_cachedBarSpacing.setWidth((m_cachedBarThickness.width() * 2) * (spacing.width() + 1.0f));

++         m_cachedBarSpacing.setHeight((m_cachedBarThickness.height() * 2)

++                                      * (spacing.height() + 1.0f));

++     } else {

++         m_cachedBarSpacing = m_cachedBarThickness * 2 + spacing * 2;

++     }

++

++     m_changeTracker.axisRangeChanged = true;

++     m_changeTracker.selectedBarChanged = true;

++

++     // Calculate here and at setting sample space

++     calculateSceneScalingFactors();

++     setSeriesVisualsDirty(true);

++ }

++

++ void QQuickGraphsBars::updateBarSeriesMargin(QSizeF margin)

++ {

++     m_cachedBarSeriesMargin = margin;

++     calculateSeriesStartPosition();

++     calculateSceneScalingFactors();

++     setSeriesVisualsDirty(true);

++ }

++

++ QT_END_NAMESPACE

++

++ #include "moc_qquickgraphsbars_p.cpp"

Revision control