HOWTO: Use the isPointInStroke function to make your line clickable

• Introduction
• The original Line chart
• The Line chart with the draw event listener
• The Line chart with the draw event listener and the click event listener
• An alternative method using the Drawing API Line object

Introduction

Currently, you can use the drawing api Poly object to draw a shape around your line and then use the Poly objects tooltip or events to add interactivity. Now though, since the addition of the isPointInStroke function to the standard canvas api, the process is made much easier as the example below shows. It involves:

• Draw your Line chart as normal
• Add a draw event listener that draws a transparent line using the Line chart coordinates
• Since this transparent line is the last path drawn on the canvas we can add a click event and test using the isPointInStroke function.
• If the test is positive - the line has been clicked.

The original Line chart

Here is the original Line chart before the new path is created.

<script>
    new RGraph.Line({
        id: 'cvs',
        data: [4,8,6,3,5,2,4],
        options: {
            marginInner: 15,
            linewidth: 5,
            xaxisLabels: ['Mon','Tue','Wed','Thu','Fri','Sat','Sun'],
            backgroundGridVlinesCount: 6,
            textSize: 14
        }
    }).draw();
</script>

The Line chart with the draw event listener

Now a draw event listener is added that draws a line. Since this is drawn after the Line chart it will be the last path that is drawn on the canvas. Normally you would make this a transparent color - but so that you can see it, it's been drawn in semi-opaque black.

<script>
    line = new RGraph.Line({
        id: 'cvs',
        data: [4,8,6,3,5,2,4],
        options: {
            marginInner: 15,
            linewidth: 5,
            xaxisLabels: ['Mon','Tue','Wed','Thu','Fri','Sat','Sun'],
            backgroundGridVlinesCount: 6,
            textSize: 14,
            events: {
                draw: function (obj)
                {
                    var coords = obj.coords
            
                    obj.context.beginPath();
                        obj.context.lineWidth = 10;
                        obj.context.lineCap = 'round';
                        obj.context.strokeStyle = 'rgba(0,0,0,0.25)';
                        
                        obj.context.moveTo(coords[0][0], coords[0][1]);
                        
                        
                        for (var i=1; i<coords.length; i+=1) {
                            obj.context.lineTo(coords[i][0], coords[i][1]);
                        }
                    obj.context.stroke();
                }
            }
        }
    }).draw();
</script>

The Line chart with the draw event listener and the click event listener

Now the click event is added to the canvas. Since the line that we drew using the Line chart coordinates was the last path added to the canvas the isPointInStroke function can be used to see if the path (ie the line) was clicked.

<script>
    line = new RGraph.Line({
        id: 'cvs',
        data: [4,8,6,3,5,2,4],
        options: {
            marginInner: 15,
            linewidth: 5,
            xaxisLabels: ['Mon','Tue','Wed','Thu','Fri','Sat','Sun'],
            backgroundGridVlinesCount: 6,
            textSize: 14,
            events: {
                draw: function (obj)
                {
                    var coords = obj.coords
            
                    obj.context.beginPath();
                        obj.context.lineWidth   = 10;
                        obj.context.lineCap     = 'round';
                        obj.context.strokeStyle = 'rgba(0,0,0,0.2)';
                        
                        obj.context.moveTo(coords[0][0], coords[0][1]);
                        
                        for (var i=1; i<coords.length; i+=1) {
                            obj.context.lineTo(coords[i][0], coords[i][1]);
                        }
                    obj.context.stroke();
                }
            }
        }
    }).draw();


    //
    // Define the mousemove event that changes the cursor
    //
    line.canvas.onmousemove =  function (e)
    {
        var mouseXY = RGraph.getMouseXY(e);
        var over    = line.context.isPointInStroke(mouseXY[0], mouseXY[1]);

        if (over) {
            e.target.style.cursor = 'pointer';
        } else {
            e.target.style.cursor = 'default';
        }
    };


    //
    // Define the click event listener that handles a click on
    // the line
    //
    line.canvas.onclick = function (e)
    {
        var mouseXY = RGraph.getMouseXY(e);

        if (line.context.isPointInStroke(mouseXY[0], mouseXY[1])) {
            alert('The line was clicked');
        }
    };
</script>

An alternative method using the Drawing API Line object

An alternative method using the drawing API Line object can eliminate a lot of custom code - meaning that you just need to pass the coordinates of the line - which are stored in the Line chart coords array after it's been drawn - to the drawing API Line object. This method looks like this:

[No canvas support]

<script>
    line = new RGraph.Line({
        id: 'cvs2',
        data: [4,5,6,8,5,2,3],
        options: {
            spline: true
        }
    }).draw();
    
    new RGraph.Drawing.Line({
        id:'cvs',
        // Get the coordinates from the Line chart object
        coords: line.coordsSpline[0],
        
        options: {
            colorsStroke: '#ff0a',
            linewidth: 10,
            events: {
                click: function (obj, shape)
                {
                    alert('Line has been clicked!')
                },
                mousemove: function (obj, shape)
                {
                    return true;
                }
            }
        }
    }).draw();
</script>