### Installation and Deployment Script Generation

Source: https://github.com/qt/qtgraphs/blob/dev/examples/graphs/common/graphprinting/CMakeLists.txt

Configures the installation of the 'graphprinting' executable and its associated libraries and resources. It also generates a deployment script for application packaging.

```cmake
install(TARGETS graphprinting
    BUNDLE DESTINATION .
    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_BINDIR}
)

qt_generate_deploy_app_script(
    TARGET graphprinting
    OUTPUT_SCRIPT deploy_script
    NO_UNSUPPORTED_PLATFORM_ERROR
)

install(SCRIPT ${deploy_script})
```

--------------------------------

### Q3DBarsWidgetItem Implementation

Source: https://context7.com/qt/qtgraphs/llms.txt

This example demonstrates how to initialize a Q3DBarsWidgetItem, configure axes, populate data, and display it within a QQuickWidget container.

```APIDOC
## C++ Class: Q3DBarsWidgetItem

### Description
Q3DBarsWidgetItem provides a bridge to render 3D bar graphs inside a standard Qt Widget application. It utilizes QQuickWidget as the underlying rendering surface.

### Usage
1. Instantiate QQuickWidget and Q3DBarsWidgetItem.
2. Configure axes (QCategory3DAxis, QValue3DAxis).
3. Define data using QBarDataProxy and QBar3DSeries.
4. Apply themes and visual properties.
5. Add the widget to your layout.

### Key Methods
- **setWidget(QQuickWidget *widget)**: Sets the rendering surface.
- **setRowAxis(QCategory3DAxis *axis)**: Configures the row axis labels and title.
- **setColumnAxis(QCategory3DAxis *axis)**: Configures the column axis labels and title.
- **setValueAxis(QValue3DAxis *axis)**: Configures the value range and formatting.
- **addSeries(QBar3DSeries *series)**: Adds a data series to the graph.
- **setTheme(QGraphsTheme *theme)**: Sets the visual style of the graph.

### Example
```cpp
Q3DBarsWidgetItem *barGraph = new Q3DBarsWidgetItem();
barGraph->setWidget(quickWidget);
barGraph->setRowAxis(rowAxis);
barGraph->addSeries(series);
```
```

--------------------------------

### Conditional Example Inclusion for Qt Graphs

Source: https://github.com/qt/qtgraphs/blob/dev/examples/graphs/common/CMakeLists.txt

This CMake script snippet demonstrates how to conditionally add examples to the Qt Graphs module. It checks for the availability of target modules like Qt::Quick and Qt6::PrintSupport, as well as specific feature flags related to 2D and 3D graphs, before including example builds.

```cmake
if(TARGET Qt::Quick)
    if(TARGET Qt6::PrintSupport AND QT_FEATURE_graphs_3d_bars3d AND QT_FEATURE_graphs_2d_line)
        qt_internal_add_example(graphprinting)
    endif()
    if(QT_FEATURE_graphs_3d_bars3d AND QT_FEATURE_graphs_3d_scatter3d AND QT_FEATURE_graphs_3d_surface3d AND QT_FEATURE_graphs_2d_area AND QT_FEATURE_graphs_2d_bar AND QT_FEATURE_graphs_2d_donut_pie AND QT_FEATURE_graphs_2d_spline)
        qt_internal_add_example(aerospacehub)
    endif()
endif()
```

--------------------------------

### Install QtGraphs Designer Assets via CMake

Source: https://github.com/qt/qtgraphs/blob/dev/src/graphs2d/qml/designer/CMakeLists.txt

This snippet uses CMake's file globbing to identify PNG images and the qt_copy_or_install function to deploy them along with QML files and metadata to the Qt installation path.

```cmake
file(GLOB_RECURSE designer_image_files
    RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}"
    "images/*.png"
)
qt_path_join(images_destination ${QT_INSTALL_DIR} "${INSTALL_QMLDIR}/QtGraphs/designer/images")
qt_copy_or_install(
    FILES
        ${designer_image_files}
    DESTINATION "${images_destination}"
)

qt_path_join(destination ${QT_INSTALL_DIR} "${INSTALL_QMLDIR}/QtGraphs/designer")
qt_copy_or_install(
    FILES
        GraphsViewSpecifics.qml
        qtgraphs2d.metainfo
    DESTINATION "${destination}"
)

add_subdirectory(default)
```

--------------------------------

### Configure GraphsView Container in QML

Source: https://context7.com/qt/qtgraphs/llms.txt

Demonstrates how to initialize a GraphsView container with ValueAxis definitions and a custom theme. This setup provides the canvas for rendering 2D data series.

```QML
import QtQuick
import QtGraphs

Item {
    width: 800
    height: 600

    GraphsView {
        anchors.fill: parent
        anchors.margins: 16

        axisX: ValueAxis {
            min: 0
            max: 10
            tickInterval: 1
            subTickCount: 4
            labelDecimals: 1
            titleText: "Time (s)"
        }

        axisY: ValueAxis {
            min: 0
            max: 100
            tickInterval: 20
            labelDecimals: 0
            titleText: "Value"
        }

        theme: GraphsTheme {
            colorScheme: GraphsTheme.ColorScheme.Dark
            theme: GraphsTheme.Theme.QtGreen
        }

        LineSeries {
            width: 3
            XYPoint { x: 0; y: 10 }
            XYPoint { x: 2; y: 45 }
            XYPoint { x: 4; y: 30 }
            XYPoint { x: 6; y: 78 }
            XYPoint { x: 8; y: 55 }
            XYPoint { x: 10; y: 90 }
        }
    }
}
```

--------------------------------

### Render Filled Area Graphs with AreaSeries

Source: https://context7.com/qt/qtgraphs/llms.txt

Illustrates the use of AreaSeries to draw filled regions between data points. Includes an example of applying a LinearGradient for visual styling.

```QML
import QtQuick
import QtQuick.Shapes
import QtGraphs

GraphsView {
    id: graph
    anchors.fill: parent

    axisX: ValueAxis {
        min: 1
        max: 12
        tickInterval: 1
        titleText: "Month"
    }

    axisY: ValueAxis {
        min: 0
        max: 500
        tickInterval: 100
        titleText: "Revenue ($K)"
    }

    AreaSeries {
        color: "#173DDE"
        borderColor: "#3673FC"

        gradient: LinearGradient {
            x1: 0; y1: 0
            x2: 0; y2: graph.height
            GradientStop { position: 0.0; color: "#3673FC" }
            GradientStop { position: 1.0; color: "#0A1845" }
        }

        upperSeries: SplineSeries {
            XYPoint { x: 1; y: 100 }
            XYPoint { x: 3; y: 180 }
            XYPoint { x: 6; y: 320 }
            XYPoint { x: 9; y: 410 }
            XYPoint { x: 12; y: 480 }
        }
    }
}
```

--------------------------------

### Configure tst_qginput Test with Qt Libraries

Source: https://github.com/qt/qtgraphs/blob/dev/tests/auto/cpptest/qginput/CMakeLists.txt

This CMake code snippet configures a test target named 'tst_qginput'. It specifies the source file 'tst_input.cpp' and links against the necessary Qt libraries: Qt::Gui, Qt::Graphs, and Qt::GraphsWidgets. This setup is crucial for tests that interact with Qt's graphical elements and the graphs module.

```cmake
# Copyright (C) 2023 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

qt_internal_add_test(tst_qginput
    SOURCES
        tst_input.cpp
    LIBRARIES
        Qt::Gui
        Qt::Graphs
        Qt::GraphsWidgets
)
```

--------------------------------

### CMake Integration for Qt Graphs Projects

Source: https://context7.com/qt/qtgraphs/llms.txt

Shows how to integrate Qt Graphs into a CMake project. It includes finding the necessary Qt6 modules (Core, Graphs, GraphsWidgets) and linking them to executables for both QML and widget applications. This setup is essential for using Qt Graphs functionalities.

```cmake
cmake_minimum_required(VERSION 3.16)
project(MyGraphsApp VERSION 1.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(Qt6 REQUIRED COMPONENTS
    Core
    Quick
    QuickWidgets
    Graphs
    GraphsWidgets  # Optional: for widget support
)

qt_standard_project_setup()

# QML application
qt_add_executable(mygraphsapp
    main.cpp
)

qt_add_qml_module(mygraphsapp
    URI MyGraphsApp
    VERSION 1.0
    QML_FILES
        Main.qml
        MyChart.qml
    RESOURCES
        images/background.png
)

target_link_libraries(mygraphsapp PRIVATE
    Qt6::Core
    Qt6::Quick
    Qt6::Graphs
)

# Widget application (optional)
qt_add_executable(widgetgraphsapp
    widget_main.cpp
    graphmodifier.cpp
    graphmodifier.h
)

target_link_libraries(widgetgraphsapp PRIVATE
    Qt6::Core
    Qt6::Widgets
    Qt6::QuickWidgets
    Qt6::Graphs
    Qt6::GraphsWidgets
)
```

--------------------------------

### Create Pie and Donut Charts with PieSeries

Source: https://context7.com/qt/qtgraphs/llms.txt

Demonstrates how to use PieSeries and PieSlice to render a pie chart. Setting the holeSize property transforms the chart into a donut visualization.

```QML
import QtQuick
import QtGraphs

GraphsView {
    anchors.fill: parent

    axisX: ValueAxis { visible: false; gridVisible: false }
    axisY: ValueAxis { visible: false; gridVisible: false }

    PieSeries {
        id: pieSeries
        holeSize: 0.4
        angleSpanVisibleLimit: 60

        PieSlice {
            label: "Critical"
            value: 15
            color: "#FF4444"
            borderColor: "#CC0000"
            labelVisible: true
            labelPosition: PieSlice.LabelPosition.InsideHorizontal
            exploded: true
        }

        PieSlice {
            label: "Warning"
            value: 30
            color: "#FFAA00"
            borderColor: "#CC8800"
            labelVisible: true
            labelPosition: PieSlice.LabelPosition.InsideHorizontal
        }

        PieSlice {
            label: "Normal"
            value: 55
            color: "#44CC44"
            borderColor: "#228822"
            labelVisible: true
            labelPosition: PieSlice.LabelPosition.InsideHorizontal
        }
    }
}
```

--------------------------------

### Configure Qt Graphs Project with CMake

Source: https://github.com/qt/qtgraphs/blob/dev/examples/graphs/common/aerospacehub/CMakeLists.txt

This CMake configuration initializes the project, finds necessary Qt 6 components (Quick, Graphs, Quick3D), and defines the executable target. It includes QML module registration and links the required libraries to the project.

```cmake
cmake_minimum_required(VERSION 3.16)
project(aerospacehub VERSION 0.1 LANGUAGES CXX)
find_package(Qt6 REQUIRED COMPONENTS Quick Graphs Quick3D)
qt_standard_project_setup(REQUIRES 6.8)
qt_add_executable(aerospacehub main.cpp)
qt_add_qml_module(aerospacehub
    URI AerospaceHubExample
    QML_FILES Main.qml qml/Area2DGraph.qml
)
target_link_libraries(aerospacehub PRIVATE Qt6::Quick Qt6::Graphs Qt6::Quick3D)
```

--------------------------------

### Configure Qt Test tst_qgabstractaxis2d

Source: https://github.com/qt/qtgraphs/blob/dev/tests/auto/cpp2dtest/qgaxis-abstract/CMakeLists.txt

This CMake code configures a Qt test target named tst_qgabstractaxis2d. It specifies the source files, include directories, and the Qt libraries required for the test to compile and run. This setup is common for internal Qt tests.

```cmake
# Copyright (C) 2024 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

qt_internal_add_test(tst_qgabstractaxis2d
    SOURCES
        tst_abstractaxis.cpp
    INCLUDE_DIRECTORIES
        ../common
    LIBRARIES
        Qt::Gui
        Qt::GuiPrivate
        Qt::Graphs
)
```

--------------------------------

### Configure Qt Graphs Build Summary and Tracepoints

Source: https://github.com/qt/qtgraphs/blob/dev/src/CMakeLists.txt

Sets up the build summary section for Qt Graphs and generates tracepoints for the module. This ensures proper visibility of feature support and instrumentation in the build output.

```cmake
qt_configure_add_summary_section(NAME "Qt Graphs Support")
qt_configure_add_summary_entry(ARGS "graphs-2d")
qt_configure_add_summary_entry(ARGS "graphs-3d")
qt_configure_end_summary_section()

qt_internal_generate_tracepoints(Graphs graphs
    SOURCES
        ${TRACE_SOURCES}
        ${TRACE_SOURCES_2D}
)
```

--------------------------------

### Configure Qt Graphs Test Target

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/scattertest/CMakeLists.txt

This CMake code configures a test target named 'tst_scattertest' for the Qt Graphs module. It specifies the required Qt modules (Gui, Widgets, Graphs, GraphsWidgets) and lists the source files for the test. This setup is typically used for internal Qt testing.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_scattertest LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

set(CMAKE_INCLUDE_CURRENT_DIR ON)

qt_internal_add_manual_test(tst_scattertest
    GUI
    SOURCES
        main.cpp
        scatterchart.cpp scatterchart.h
    )
target_link_libraries(tst_scattertest PUBLIC
    Qt::Gui
    Qt::Widgets
    Qt::Graphs
    Qt::GraphsWidgets
    )
```

--------------------------------

### CMakeLists.txt Configuration for Qt Graphs Surface Layers Test

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/qmlsurfacelayers/CMakeLists.txt

This CMakeLists.txt file configures the build for the tst_qmlsurfacelayers test. It sets up the project, finds necessary Qt internal components, defines the test executable, links required Qt modules (Core, Gui, Qml, Quick, Graphs), and adds QML files and image resources to the build.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_qmlsurfacelayers LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

set(CMAKE_INCLUDE_CURRENT_DIR ON)

qt_internal_add_manual_test(tst_qmlsurfacelayers
    GUI
    SOURCES
        main.cpp
    )

target_link_libraries(tst_qmlsurfacelayers PUBLIC
    Qt::Core
    Qt::Gui
    Qt::Qml
    Qt::Quick
    Qt::Graphs
)

set(qmlsurfacelayers_resource_files
    "qml/qmlsurfacelayers/main.qml"
    "qml/qmlsurfacelayers/ResizableRect.qml"
)

qt6_add_resources(tst_qmlsurfacelayers "qmlsurfacelayers"
    PREFIX
        "/"
    FILES
        ${qmlsurfacelayers_resource_files}
)
set(qmlsurfacelayers1_resource_files
    "layer_1.png"
    "layer_2.png"
    "layer_3.png"
)

qt6_add_resources(tst_qmlsurfacelayers "qmlsurfacelayers1"
    PREFIX
        "/heightmaps"
    FILES
        ${qmlsurfacelayers1_resource_files}
)
```

--------------------------------

### CMake Configuration for Qt Graphs Application

Source: https://github.com/qt/qtgraphs/blob/dev/examples/graphs/3d/bars/CMakeLists.txt

This CMakeLists.txt file configures a Qt 6 application named 'bars'. It finds and links the required Qt modules, including Qt Graphs, and sets up the build process for C++ and QML files. The configuration ensures the application can be built and run as an example demonstrating Qt Graphs.

```cmake
cmake_minimum_required(VERSION 3.16)
project(bars LANGUAGES CXX)

set(CMAKE_INCLUDE_CURRENT_DIR ON)

set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)

if(NOT DEFINED INSTALL_EXAMPLESDIR)
  set(INSTALL_EXAMPLESDIR "examples")
endif()

set(INSTALL_EXAMPLEDIR "${INSTALL_EXAMPLESDIR}")

find_package(Qt6 COMPONENTS Core)
find_package(Qt6 COMPONENTS Gui)
find_package(Qt6 COMPONENTS Quick)
find_package(Qt6 COMPONENTS Quick3D)
find_package(Qt6 COMPONENTS Graphs)

qt_add_executable(bars
    main.cpp
)
set_target_properties(bars PROPERTIES
    WIN32_EXECUTABLE TRUE
    MACOSX_BUNDLE TRUE
)

target_link_libraries(bars PUBLIC
    Qt::Core
    Qt::Gui
    Qt::Quick
    Qt::Quick3D
    Qt::Graphs
)

qt6_add_qml_module(bars
    URI BarsExample
    NO_RESOURCE_TARGET_PATH
    QML_FILES
        qml/bars/Axes.qml
        qml/bars/Data.qml
        qml/bars/main.qml
)

install(TARGETS bars
    RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
    BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
    LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
)
```

--------------------------------

### Create and Configure 3D Bar Graph with Q3DBarsWidgetItem in C++

Source: https://context7.com/qt/qtgraphs/llms.txt

This C++ code demonstrates how to initialize and configure a 3D bar graph using Q3DBarsWidgetItem. It sets up axes, visual properties, data series, and applies a theme for a Qt widget application. Dependencies include QtWidgets, QtQuickWidgets, and QtGraphs modules.

```cpp
#include <QtWidgets/QApplication>
#include <QtWidgets/QWidget>
#include <QtWidgets/QHBoxLayout>
#include <QtQuickWidgets/QQuickWidget>
#include <QtGraphs/Q3DBarsWidgetItem>
#include <QtGraphs/QBar3DSeries>
#include <QtGraphs/QBarDataProxy>
#include <QtGraphs/QCategory3DAxis>
#include <QtGraphs/QValue3DAxis>
#include <QtGraphs/QGraphsTheme>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    // Create the widget and graph
    QQuickWidget *quickWidget = new QQuickWidget();
    Q3DBarsWidgetItem *barGraph = new Q3DBarsWidgetItem();
    barGraph->setWidget(quickWidget);

    // Create and configure axes
    QCategory3DAxis *rowAxis = new QCategory3DAxis();
    rowAxis->setLabels(QStringList() << "2022" << "2023" << "2024");
    rowAxis->setTitle("Year");

    QCategory3DAxis *colAxis = new QCategory3DAxis();
    colAxis->setLabels(QStringList() << "Q1" << "Q2" << "Q3" << "Q4");
    colAxis->setTitle("Quarter");

    QValue3DAxis *valueAxis = new QValue3DAxis();
    valueAxis->setRange(0, 100);
    valueAxis->setTitle("Sales (M$)");
    valueAxis->setLabelFormat("%.1f");

    barGraph->setRowAxis(rowAxis);
    barGraph->setColumnAxis(colAxis);
    barGraph->setValueAxis(valueAxis);

    // Configure visual properties
    barGraph->setShadowQuality(QtGraphs3D::ShadowQuality::SoftHigh);
    barGraph->setSelectionMode(QtGraphs3D::SelectionFlag::Item);
    barGraph->setCameraPreset(QtGraphs3D::CameraPreset::IsometricLeftHigh);
    barGraph->setBarThickness(0.7f);
    barGraph->setBarSpacing(QSizeF(0.5, 0.5));

    // Create data proxy and series
    QBarDataProxy *proxy = new QBarDataProxy();
    QBar3DSeries *series = new QBar3DSeries(proxy);
    series->setItemLabelFormat("@rowLabel @colLabel: @valueLabel M$");
    series->setMeshSmooth(true);

    // Populate data
    QBarDataArray *dataArray = new QBarDataArray();
    for (int row = 0; row < 3; row++) {
        QBarDataRow *dataRow = new QBarDataRow();
        for (int col = 0; col < 4; col++) {
            *dataRow << QBarDataItem(20.0f + row * 10 + col * 5);
        }
        *dataArray << dataRow;
    }
    proxy->resetArray(dataArray);

    // Add series to graph
    barGraph->addSeries(series);

    // Set up theme
    QGraphsTheme *theme = new QGraphsTheme();
    theme->setTheme(QGraphsTheme::Theme::QtGreen);
    theme->setColorScheme(QGraphsTheme::ColorScheme::Dark);
    theme->setLabelBorderVisible(true);
    barGraph->setTheme(theme);

    // Create layout and window
    QWidget *container = new QWidget();
    QHBoxLayout *layout = new QHBoxLayout(container);
    layout->addWidget(quickWidget);
    container->setMinimumSize(800, 600);
    container->show();

    return app.exec();
}
```

--------------------------------

### Configure CMake for Qt Graphs Manual Test

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/qmlbarsrowcolors/CMakeLists.txt

This CMake script initializes a manual test project, links the required Qt modules (Core, Gui, Qml, Quick, Graphs), and registers QML files as resources. It ensures the environment is correctly set up for testing QML-based bar charts.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_qmlbarsrowcolors LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

set(CMAKE_INCLUDE_CURRENT_DIR ON)

qt_internal_add_manual_test(tst_qmlbarsrowcolors
    GUI
    SOURCES
        main.cpp
    )

target_link_libraries(tst_qmlbarsrowcolors PUBLIC
    Qt::Core
    Qt::Gui
    Qt::Qml
    Qt::Quick
    Qt::Graphs
)

set(qmlbarsrowcolors_resource_files
    "qml/qmlbarsrowcolors/Axes.qml"
    "qml/qmlbarsrowcolors/Data.qml"
    "qml/qmlbarsrowcolors/main.qml"
)

qt6_add_resources(tst_qmlbarsrowcolors "qmlbarsrowcolors"
    PREFIX
        "/"
    FILES
        ${qmlbarsrowcolors_resource_files}
)
```

--------------------------------

### CMake: Conditional Build Setup for Qt Graphs

Source: https://github.com/qt/qtgraphs/blob/dev/tests/baseline/CMakeLists.txt

This snippet configures the CMake build for Qt Graphs. It sets the minimum CMake version and project name, and finds the necessary Qt build internals for standalone tests. It also handles special cases for including test modules and graphs subdirectory based on existing targets and features.

```cmake
# Copyright (C) 2024 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    cmake_minimum_required(VERSION 3.16)
    project(tst_qgraphs LANGUAGES CXX)
    find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST)
endif()

# Special case: test includes the QBaselineTest module sources from qtbase directly
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../../../qtbase/tests/baseline/shared"
    AND TARGET Qt6::Quick3D)
    add_subdirectory(scenegrabber)
    if (QT_FEATURE_process)
        add_subdirectory(graphs)
    endif()
endif()
```

--------------------------------

### Visualize Smooth Curves with SplineSeries

Source: https://context7.com/qt/qtgraphs/llms.txt

Shows how to implement a SplineSeries to display continuous data as a smooth curve. It utilizes XYPoint elements to define the path of the spline.

```QML
import QtQuick
import QtGraphs

GraphsView {
    anchors.fill: parent

    axisX: ValueAxis {
        min: 1
        max: 24
        tickInterval: 2
        titleText: "Hour"
    }

    axisY: ValueAxis {
        max: 100
        tickInterval: 20
        titleText: "Power Output (MW)"
    }

    SplineSeries {
        id: powerOutput
        hoverable: true
        width: 3
        color: "#3673FC"

        XYPoint { x: 1; y: 10 }
        XYPoint { x: 4; y: 25 }
        XYPoint { x: 8; y: 65 }
        XYPoint { x: 12; y: 85 }
        XYPoint { x: 16; y: 70 }
        XYPoint { x: 20; y: 45 }
        XYPoint { x: 24; y: 20 }
    }
}
```

--------------------------------

### Configure Qt Baseline Graph Test Executable (CMake)

Source: https://github.com/qt/qtgraphs/blob/dev/tests/baseline/graphs/CMakeLists.txt

This CMake script configures the 'tst_baseline_graphs' test executable. It collects test data, specifies source files, defines preprocessor macros, includes directories, links necessary Qt libraries (Gui, Network), and sets up dependencies on other Qt modules like Quick3D and qgraphs_qmlscenegrabber. The output directory is set to a special parent location.

```cmake
# Copyright (C) 2024 The Qt Company Ltd.
# SPDX-License-Identifier: BSD-3-Clause

# Collect test data
list(APPEND test_data "../data")
set(BASELINE_DIR "../../../../qtbase/tests/baseline/shared")

qt_internal_add_test(tst_baseline_graphs
    OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/.." # special case
    SOURCES
        ${BASELINE_DIR}/baselineprotocol.cpp
        ${BASELINE_DIR}/baselineprotocol.h
        ${BASELINE_DIR}/lookup3.cpp
        ${BASELINE_DIR}/qbaselinetest.cpp
        ${BASELINE_DIR}/qbaselinetest.h
        tst_baseline_graphs.cpp
    DEFINES
        QMAKESPEC=""
    INCLUDE_DIRECTORIES
        ${BASELINE_DIR}
    LIBRARIES
        Qt::Gui
        Qt::Network
    TESTDATA ${test_data}
)

add_dependencies(tst_baseline_graphs Qt6::Quick3D)
add_dependencies(tst_baseline_graphs qgraphs_qmlscenegrabber)

```

--------------------------------

### Create C++ 3D Surface Graph with QtGraphs

Source: https://context7.com/qt/qtgraphs/llms.txt

Demonstrates how to create a 3D surface graph using Q3DSurfaceWidgetItem and QSurfaceDataProxy in C++. It generates data for a mathematical function (z = sin(x) * cos(y)), configures axes, and applies visual styling including gradients for coloring. Dependencies include QtGraphs modules.

```cpp
#include <QtGraphs/Q3DSurfaceWidgetItem>
#include <QtGraphs/QSurface3DSeries>
#include <QtGraphs/QSurfaceDataProxy>
#include <QtGraphs/QValue3DAxis>
#include <cmath>

void createSurfaceGraph(Q3DSurfaceWidgetItem *surfaceGraph)
{
    // Create data proxy and series
    QSurfaceDataProxy *proxy = new QSurfaceDataProxy();
    QSurface3DSeries *series = new QSurface3DSeries(proxy);
    series->setDrawMode(QSurface3DSeries::DrawSurfaceAndWireframe);
    series->setFlatShadingEnabled(false);

    // Generate surface data: z = sin(x) * cos(y)
    int sampleCountX = 50;
    int sampleCountZ = 50;
    float stepX = 4.0f * M_PI / float(sampleCountX - 1);
    float stepZ = 4.0f * M_PI / float(sampleCountZ - 1);

    QSurfaceDataArray *dataArray = new QSurfaceDataArray();
    dataArray->reserve(sampleCountZ);

    for (int i = 0; i < sampleCountZ; i++) {
        QSurfaceDataRow *newRow = new QSurfaceDataRow();
        newRow->reserve(sampleCountX);

        float z = float(i) * stepZ - 2.0f * M_PI;
        for (int j = 0; j < sampleCountX; j++) {
            float x = float(j) * stepX - 2.0f * M_PI;
            float y = sin(x) * cos(z);
            newRow->append(QSurfaceDataItem(x, y, z));
        }
        dataArray->append(newRow);
    }

    proxy->resetArray(dataArray);

    // Configure axes
    surfaceGraph->axisX()->setRange(-2.0f * M_PI, 2.0f * M_PI);
    surfaceGraph->axisX()->setTitle("X Axis");
    surfaceGraph->axisX()->setTitleVisible(true);
    surfaceGraph->axisX()->setLabelFormat("%.2f");

    surfaceGraph->axisY()->setRange(-1.0f, 1.0f);
    surfaceGraph->axisY()->setTitle("Y = sin(x) * cos(z)");
    surfaceGraph->axisY()->setTitleVisible(true);

    surfaceGraph->axisZ()->setRange(-2.0f * M_PI, 2.0f * M_PI);
    surfaceGraph->axisZ()->setTitle("Z Axis");
    surfaceGraph->axisZ()->setTitleVisible(true);

    // Configure visual properties
    surfaceGraph->setShadowQuality(QtGraphs3D::ShadowQuality::Medium);
    surfaceGraph->setCameraPreset(QtGraphs3D::CameraPreset::IsometricLeft);

    // Create gradient for surface coloring
    QLinearGradient gradient;
    gradient.setColorAt(0.0, Qt::darkBlue);
    gradient.setColorAt(0.25, Qt::blue);
    gradient.setColorAt(0.5, Qt::green);
    gradient.setColorAt(0.75, Qt::yellow);
    gradient.setColorAt(1.0, Qt::red);

    series->setBaseGradient(gradient);
    series->setColorStyle(QGraphsTheme::ColorStyle::RangeGradient);

    surfaceGraph->addSeries(series);
}
```

--------------------------------

### Configure Qt Graphs Manual Test with CMake

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/qmlrenderslicetoimage/CMakeLists.txt

This CMake configuration sets up a manual test project named tst_qmlrenderslicetoimage. It includes the necessary source files, links the required Qt::Gui and Qt::Graphs libraries, and embeds QML and image resources into the binary.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_qmlrenderslicetoimage LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

qt_internal_add_manual_test(tst_qmlrenderslicetoimage
    GUI
    SOURCES
        main.cpp
    )
target_link_libraries(tst_qmlrenderslicetoimage PUBLIC
    Qt::Gui
    Qt::Graphs
    )

set(qmlrenderslicetoimage_resource_files
    "qml/qmlrenderslicetoimage/main.qml"
    "qml/qmlrenderslicetoimage/SurfaceGraph.qml"
    "qml/qmlrenderslicetoimage/BarGraph.qml"
    )

qt_internal_add_resource(tst_qmlrenderslicetoimage "qmlgrabsliceview"
    PREFIX
    "/"
    FILES
    ${qmlrenderslicetoimage_resource_files}
    )

set(qmlrenderslicetoimage_image_resource_files
    "layer_1.png"
    "layer_2.png"
    "layer_3.png"
)

qt6_add_resources(tst_qmlrenderslicetoimage "qmlsurfacelayers1"
    PREFIX
        "/heightmaps"
    FILES
        ${qmlrenderslicetoimage_image_resource_files}
)
```

--------------------------------

### Implement LineSeries with Custom Markers

Source: https://context7.com/qt/qtgraphs/llms.txt

Shows how to use LineSeries to plot data points connected by lines, utilizing a custom QML component as a pointDelegate for visual styling.

```QML
import QtQuick
import QtGraphs

GraphsView {
    anchors.fill: parent

    axisX: ValueAxis { max: 5; tickInterval: 1 }
    axisY: ValueAxis { max: 10; tickInterval: 2 }

    theme: GraphsTheme {
        colorScheme: GraphsTheme.ColorScheme.Dark
        seriesColors: ["#2CDE85", "#DBEB00"]
    }

    component Marker : Rectangle {
        width: 16
        height: 16
        color: "#ffffff"
        radius: width * 0.5
        border.width: 4
        border.color: "#000000"
    }

    LineSeries {
        id: lineSeries1
        width: 4
        pointDelegate: Marker { }
        XYPoint { x: 0; y: 0 }
        XYPoint { x: 1; y: 2.1 }
        XYPoint { x: 2; y: 3.3 }
        XYPoint { x: 3; y: 2.1 }
        XYPoint { x: 4; y: 4.9 }
        XYPoint { x: 5; y: 3.0 }
    }

    LineSeries {
        id: lineSeries2
        width: 4
        pointDelegate: Marker { }
        XYPoint { x: 0; y: 5.0 }
        XYPoint { x: 1; y: 3.3 }
        XYPoint { x: 2; y: 7.1 }
        XYPoint { x: 3; y: 7.5 }
        XYPoint { x: 4; y: 6.1 }
        XYPoint { x: 5; y: 3.2 }
    }
}
```

--------------------------------

### Implement 2D ScatterSeries in QML

Source: https://context7.com/qt/qtgraphs/llms.txt

Demonstrates how to use ScatterSeries to plot discrete data points on a 2D plane. It includes configuration for axes, themes, and multiple series with distinct markers.

```qml
import QtQuick
import QtGraphs

GraphsView {
    anchors.fill: parent

    axisX: ValueAxis {
        min: 0
        max: 100
        tickInterval: 20
        titleText: "Temperature (°C)"
    }

    axisY: ValueAxis {
        min: 0
        max: 100
        tickInterval: 20
        titleText: "Humidity (%)"
    }

    theme: GraphsTheme {
        colorScheme: GraphsTheme.ColorScheme.Dark
        seriesColors: ["#FF6B6B", "#4ECDC4"]
    }

    ScatterSeries {
        id: indoorData
        pointMarker: ScatterSeries.PointMarker.Circle
        markerSize: 12

        XYPoint { x: 22; y: 45 }
        XYPoint { x: 24; y: 48 }
        XYPoint { x: 23; y: 52 }
        XYPoint { x: 25; y: 47 }
        XYPoint { x: 21; y: 55 }
    }

    ScatterSeries {
        id: outdoorData
        pointMarker: ScatterSeries.PointMarker.Square
        markerSize: 10

        XYPoint { x: 35; y: 30 }
        XYPoint { x: 38; y: 25 }
        XYPoint { x: 42; y: 20 }
        XYPoint { x: 28; y: 65 }
        XYPoint { x: 15; y: 80 }
    }
}
```

--------------------------------

### Executable and QML Module Creation in CMake

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/qmlsingletonthemetest/CMakeLists.txt

This CMake code defines an executable target 'tst_qmltestsingletontheme' and sets up a QML module named 'SingletonThemeTest'. It includes source files, marks a specific QML file as a singleton type, and adds a custom target for QML files.

```cmake
qt_add_executable(tst_qmltestsingletontheme
    main.cpp
)
add_test(NAME tst_qmltestsingletontheme COMMAND $<TARGET_FILE:tst_qmltestsingletontheme>)

# no need to copy around qml test files for shadow builds - just set the respective define
add_definitions(-DQUICK_TEST_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}")

file(GLOB_RECURSE QML_FILES *.qml)
set_source_files_properties(SingletonTheme.qml
    PROPERTIES QT_QML_SINGLETON_TYPE TRUE)
add_custom_target(singletontheme_qmlfiles SOURCES ${QML_FILES})

qt_add_qml_module(tst_qmltestsingletontheme
    URI SingletonThemeTest
    QML_FILES
        SingletonTheme.qml
)
```

--------------------------------

### CMake Project Configuration for Qt Graphs Application

Source: https://github.com/qt/qtgraphs/blob/dev/examples/graphs/3d/scatter/CMakeLists.txt

This CMakeLists.txt file sets up a Qt 6 project for a scatter plot application. It finds the required Qt modules (Core, Gui, Quick, Quick3D, Graphs), defines the main executable 'scatter', and links against the necessary Qt libraries. It also configures a QML module for the application's user interface.

```cmake
cmake_minimum_required(VERSION 3.16)
project(scatter LANGUAGES CXX)

if(NOT DEFINED INSTALL_EXAMPLESDIR)
  set(INSTALL_EXAMPLESDIR "examples")
endif()

set(INSTALL_EXAMPLEDIR "${INSTALL_EXAMPLESDIR}")

find_package(Qt6 6.7 REQUIRED COMPONENTS Core Gui Quick Quick3D Graphs)

qt_standard_project_setup(REQUIRES 6.7)

qt_add_executable(scatter
    main.cpp
)

set_target_properties(scatter PROPERTIES
    WIN32_EXECUTABLE TRUE
    MACOSX_BUNDLE TRUE
)

target_link_libraries(scatter PRIVATE
    Qt6::Core
    Qt6::Gui
    Qt6::Quick
    Qt6::Quick3D
    Qt6::Graphs
)

qt_add_qml_module(scatter
    URI ScatterExample
    NO_RESOURCE_TARGET_PATH
    QML_FILES
        "qml/scatter/Data.qml"
        "qml/scatter/Graph.qml"
        "qml/scatter/main.qml"
    RESOURCES
        "images/background.svg"
        "images/background_hide.svg"
        "images/camera.svg"
        "images/camera2.svg"
        "images/flatten.svg"
        "images/shadow.svg"
        "images/shadow_hide.svg"
        "images/smooth_curve.svg"
        "images/theme.svg"
)

install(TARGETS scatter
    RUNTIME DESTINATION "${INSTALL_EXAMPLEDIR}"
    BUNDLE DESTINATION "${INSTALL_EXAMPLEDIR}"
    LIBRARY DESTINATION "${INSTALL_EXAMPLEDIR}"
)
```

--------------------------------

### Configure QtGraphs Manual Test with CMake

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/itemmodel/CMakeLists.txt

This CMake script defines the project requirements, sets up the manual test executable, and links the necessary Qt6 libraries. It ensures the environment is correctly configured for building tests within the Qt ecosystem.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_itemmodel LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

set(CMAKE_INCLUDE_CURRENT_DIR ON)

qt_internal_add_manual_test(tst_itemmodel
    GUI
    SOURCES
        main.cpp
    )

target_link_libraries(tst_itemmodel PUBLIC
    Qt::Core
    Qt::Gui
    Qt::Widgets
    Qt::Graphs
    Qt::GraphsWidgets
)
```

--------------------------------

### Implement 3D Bar Graphs with Bars3D

Source: https://context7.com/qt/qtgraphs/llms.txt

Shows how to create an interactive 3D bar chart using Bars3D. It covers axis configuration, custom themes with gradients, and binding data via ItemModelBarDataProxy.

```qml
import QtQuick
import QtGraphs

Bars3D {
    id: barGraph
    width: 800
    height: 600

    shadowQuality: Graphs3D.ShadowQuality.SoftHigh
    selectionMode: Graphs3D.SelectionFlag.Item
    cameraPreset: Graphs3D.CameraPreset.IsometricLeftHigh

    rowAxis: Category3DAxis {
        labels: ["2022", "2023", "2024"]
        title: "Year"
    }

    columnAxis: Category3DAxis {
        labels: ["Q1", "Q2", "Q3", "Q4"]
        title: "Quarter"
    }

    valueAxis: Value3DAxis {
        min: 0
        max: 100
        title: "Revenue (M$)"
        labelFormat: "%.1f"
    }

    theme: GraphsTheme {
        colorScheme: GraphsTheme.ColorScheme.Dark
        colorStyle: GraphsTheme.ColorStyle.RangeGradient
        labelBorderVisible: true
        labelFont.pointSize: 35
        labelBackgroundVisible: true

        singleHighlightGradient: Gradient {
            GradientStop { position: 1.0; color: "#FFFF00" }
            GradientStop { position: 0.0; color: "#808000" }
        }
    }

    barThickness: 0.7
    barSpacing: Qt.size(0.5, 0.5)
    barSpacingRelative: false

    Bar3DSeries {
        id: barSeries
        itemLabelFormat: "Revenue @colLabel @rowLabel: @valueLabel M$"

        baseGradient: Gradient {
            GradientStop { position: 1.0; color: "#00FF00" }
            GradientStop { position: 0.0; color: "#006000" }
        }

        ItemModelBarDataProxy {
            itemModel: myDataModel
            rowRole: "year"
            columnRole: "quarter"
            valueRole: "revenue"
        }

        onSelectedBarChanged: (position) => {
            console.log("Selected:", position.x, position.y)
        }
    }
}
```

--------------------------------

### Configure CMake for QtGraphs Integration Test

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/qmlqtquick3dintegration/CMakeLists.txt

This snippet demonstrates the CMake configuration for a Qt manual test. It defines the project, finds necessary Qt6 components, links required libraries, and manages QML and video resources.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_qmlqtquick3dintegration LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

qt_internal_add_manual_test(tst_qmlqtquick3dintegration
    GUI
    SOURCES
        videodata.cpp videodata.h
        main.cpp
)

find_package(Qt6 REQUIRED COMPONENTS Multimedia MultimediaWidgets)

target_link_libraries(tst_qmlqtquick3dintegration PUBLIC
    Qt::Gui
    Qt::Graphs
    Qt::Multimedia
    Qt::MultimediaWidgets
)

qt_internal_add_resource(tst_qmlqtquick3dintegration "qmlqtquick3dintegration"
    PREFIX "/"
    FILES
        "qml/qmlqtquick3dintegration/main.qml"
        "qml/qmlqtquick3dintegration/Axes.qml"
        "qml/qmlqtquick3dintegration/Data.qml"
        "video/video.mp4"
)
```

--------------------------------

### Configure Qt Graphs Manual Test with CMake

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/barstest/CMakeLists.txt

This CMake script sets up a manual test project for Qt Graphs. It defines the project requirements, adds source files for UI components, links necessary Qt modules, and includes external resource files like meshes and textures.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_barstest LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

set(CMAKE_INCLUDE_CURRENT_DIR ON)

qt_internal_add_manual_test(tst_barstest
    GUI
    SOURCES
        chart.cpp chart.h
        sliderwrapper.cpp sliderwrapper.h
        buttonwrapper.cpp buttonwrapper.h
        main.cpp
    )
target_link_libraries(tst_barstest PUBLIC
    Qt::Gui
    Qt::Widgets
    Qt::Graphs
    Qt::GraphsWidgets
    )

set(barstest_resource_files
    "shuttle.mesh"
    "shuttle.png"
    )

qt_internal_add_resource(tst_barstest "barstest"
    PREFIX
    "/"
    FILES
    ${barstest_resource_files}
    )
```

--------------------------------

### Configure Qt Graphs Resources and QML Module

Source: https://github.com/qt/qtgraphs/blob/dev/src/CMakeLists.txt

This snippet demonstrates how to iterate through mesh and shader files to set their resource aliases and how to define the QtGraphs QML module using qt_internal_add_qml_module with its necessary dependencies and resource registrations.

```cmake
foreach(file IN LISTS mesh_resource_files)
    get_filename_component(filename ${file} NAME)
    set(RESOURCE_NAME ${filename})
    string(REPLACE ".mesh" "" RESOURCE_NAME ${RESOURCE_NAME})
    set_source_files_properties(${file} PROPERTIES QT_RESOURCE_ALIAS ${RESOURCE_NAME})
endforeach()

qt_internal_add_qml_module(Graphs
    URI "QtGraphs"
    TARGET_PRODUCT "Qt Graphs (Qt $$QT_VERSION)"
    VERSION "${PROJECT_VERSION}"
    DEPENDENCIES
        QtQuick
        QtQuick3D
    LIBRARIES
        Qt::CorePrivate
        Qt::QuickPrivate
        Qt::QuickShapesPrivate
        Qt::Quick3DPrivate
        Qt::Quick3DRuntimeRenderPrivate
)
```

--------------------------------

### Configure CMake for Qt Graphs QML Testbed

Source: https://github.com/qt/qtgraphs/blob/dev/tests/manual/qmltestbed/CMakeLists.txt

This CMake script sets up the project environment, links necessary Qt modules including Qt::Graphs, and registers QML resources and modules for the test application.

```cmake
cmake_minimum_required(VERSION 3.16)

if (NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT)
    project(tst_qmltestbed LANGUAGES C CXX)
    find_package(Qt6BuildInternals COMPONENTS STANDALONE_TEST)
endif()

qt_internal_add_manual_test(tst_qmltestbed
    GUI
    SOURCES
        main.cpp
)

target_link_libraries(tst_qmltestbed PUBLIC
    Qt::Core
    Qt::Gui
    Qt::Qml
    Qt::Quick
    Qt::Graphs
)

qt_add_qml_module(tst_qmltestbed
    URI TestbedExample
    VERSION 1.0
    SOURCES
        custombarseries.h custombarseries.cpp
        customlineseries.h customlineseries.cpp
        candlestick.h candlestick.cpp
        barsetgenerator.h barsetgenerator.cpp
        barmodelmappermodel.h barmodelmappermodel.cpp
        piemodelmappermodel.h piemodelmappermodel.cpp
)
```