Drag JavaScript Chart Axis to Scale or Pan

Demonstrates how to scale or pan the Axis on a JavaScript Chart using SciChart.js, High Performance JavaScript Charts

src/drawExample.ts
import {
    EAxisAlignment,
    EColor,
    ELabelAlignment,
    ENumericFormat,
    FastLineRenderableSeries,
    NumericAxis,
    SciChartSurface,
    XyDataSeries,
    ZoomExtentsModifier,
    EDragMode,
    YAxisDragModifier,
    XAxisDragModifier,
    SciChartJsNavyTheme,
} from "scichart";

export const drawExample = async (rootElement: string | HTMLDivElement) => {
    const { sciChartSurface, wasmContext } = await SciChartSurface.create(rootElement, {
        theme: new SciChartJsNavyTheme(),
    });

    const ID_X_AXIS_2 = "xAxis2";
    const ID_Y_AXIS_2 = "yAxis2";

    const setXAxis1 = () => {
        const xAxis = new NumericAxis(wasmContext);
        xAxis.axisAlignment = EAxisAlignment.Top;
        xAxis.axisTitle = "Drag the X-Axis to Pan";
        xAxis.labelProvider.numericFormat = ENumericFormat.Decimal;
        xAxis.labelProvider.precision = 0;
        sciChartSurface.xAxes.add(xAxis);
    };

    const setXAxis2 = () => {
        const xAxis = new NumericAxis(wasmContext, {
            id: ID_X_AXIS_2,
        });
        xAxis.axisAlignment = EAxisAlignment.Bottom;
        xAxis.axisTitle = "Drag the X-Axis to Pan";
        xAxis.labelProvider.numericFormat = ENumericFormat.Decimal;
        xAxis.labelProvider.precision = 0;
        sciChartSurface.xAxes.add(xAxis);
    };

    const setYAxis1 = () => {
        const yAxis = new NumericAxis(wasmContext);
        yAxis.axisAlignment = EAxisAlignment.Left;
        yAxis.axisTitle = "Drag the Y-Axis to Scale";
        yAxis.labelProvider.numericFormat = ENumericFormat.Decimal;
        yAxis.labelProvider.precision = 0;
        sciChartSurface.yAxes.add(yAxis);
    };

    const setYAxis2 = () => {
        const yAxis = new NumericAxis(wasmContext, {
            id: ID_Y_AXIS_2,
        });
        yAxis.axisAlignment = EAxisAlignment.Right;
        yAxis.axisTitle = "Drag the Y-Axis to Scale";
        yAxis.labelProvider.numericFormat = ENumericFormat.Decimal;
        yAxis.labelProvider.precision = 0;
        yAxis.labelStyle = { alignment: ELabelAlignment.Right };
        sciChartSurface.yAxes.add(yAxis);
    };

    const setSeries1 = () => {
        const lineSeries = new FastLineRenderableSeries(wasmContext, { stroke: EColor.Red });
        lineSeries.strokeThickness = 3;
        sciChartSurface.renderableSeries.add(lineSeries);
        const lineData = new XyDataSeries(wasmContext);

        // Define line data
        const iStep = 20;
        const fAmpltude = 100.0;
        const fFrequency = 1.0;
        for (let i = 0; i < 500 + iStep; i += iStep) {
            lineData.append(i, Math.sin((fFrequency * i * Math.PI) / 180.0) * fAmpltude);
        }

        lineSeries.dataSeries = lineData;
    };

    const setSeries2 = () => {
        const lineSeries = new FastLineRenderableSeries(wasmContext, { stroke: EColor.Purple });
        lineSeries.xAxisId = ID_X_AXIS_2;
        lineSeries.yAxisId = ID_Y_AXIS_2;
        lineSeries.strokeThickness = 3;
        sciChartSurface.renderableSeries.add(lineSeries);
        const lineData = new XyDataSeries(wasmContext);

        // Define line data
        const iStep = 10;
        const fAmpltude = 200.0;
        const fFrequency = 1.5;
        for (let i = 0; i < 1.5 * 500 + iStep; i += iStep) {
            lineData.append(i, Math.sin((fFrequency * (i - 100) * Math.PI) / 180.0) * fAmpltude);
        }

        lineSeries.dataSeries = lineData;
    };

    setXAxis1();
    setXAxis2();
    setYAxis1();
    setYAxis2();

    setSeries1();
    setSeries2();

    // Add modifiers to enable YAxis and XAxis drag with dragMode as scale or pan
    sciChartSurface.chartModifiers.add(
        new XAxisDragModifier({ dragMode: EDragMode.Panning }),
        new YAxisDragModifier({ dragMode: EDragMode.Scaling })
    );

    // Add a modifier to zoom to fit on double-click
    sciChartSurface.chartModifiers.add(new ZoomExtentsModifier());

    sciChartSurface.zoomExtents();

    return { sciChartSurface };
};

Drag Axis To Scale - JavaScript

Overview

This example demonstrates how to implement axis-drag interactivity with SciChart.js using JavaScript. The chart features dual X-axes and dual Y-axes which allow users to pan the view by dragging the X-Axis and to scale the chart by dragging the Y-Axis. It is designed to showcase how to create responsive and dynamic charts with advanced interactivity features.

Technical Implementation

The implementation begins by initializing a SciChartSurface using JavaScript as described in the Tutorial 01 - Including SciChart.js in an HTML Page using CDN. Custom axes are added using NumericAxis, with properties such as axisAlignment and custom label formatting applied via a custom labelProvider (see Custom LabelProviders: Readable Numbers - SciChart). The data series, built with XyDataSeries, are generated algorithmically (sine wave data) to simulate dynamic charting. Drag interactions are enabled through the use of XAxisDragModifier for panning and YAxisDragModifier for scaling. Additionally, a ZoomExtentsModifier ensures the chart automatically zooms to fit all data upon initialization.

Features and Capabilities

Multiple Axes Integration: The example cleanly integrates multiple axes by assigning unique IDs and specific alignments (top, bottom, left, right) so that each axis can be independently manipulated.

Interactive Dragging: Users can directly interact with the chart by dragging the axes. The X-Axis drag is set to panning mode and the Y-Axis drag is set to scaling mode, delivering an intuitive data exploration experience.

Custom Label Formatting and Theming: The axes utilize custom label formatting to display numbers in a clear and readable format. The overall chart styling is achieved with the SciChartJsNavyTheme, which provides a modern dark visual appearance. More details on customizing themes can be found in the Chart Styling - ThemeManager API.

Integration and Best Practices

This JavaScript implementation emphasizes high performance by leveraging the underlying WebAssembly context (wasmContext) for efficient rendering. Developers interested in further optimizing their charts are encouraged to review the Performance Tips & Tricks which detail best practices for rendering and memory management. The example also demonstrates how to apply interactive modifiers in a way that maintains chart responsiveness—an essential aspect when building real-world, data-intensive web applications.