CairoArrow.H

Go to the documentation of this file.

/* Copyright 2000-2018 Matt Flax <flatmax@flatmax.org>
   This file is part of GTK+ IOStream class set

   GTK+ IOStream is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GTK+ IOStream is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You have received a copy of the GNU General Public License
   along with GTK+ IOStream
 */

#ifndef CAIROARROW_H_
#define CAIROARROW_H_

#ifdef _MSC_VER
#define _USE_MATH_DEFINES
#endif
#include <math.h>
#include <cairo/cairo.h>

class CairoArrow {
    float xSide1, xSide2; 
    float ySide1, ySide2; 
    float vecX, vecY; 

    void findArrowHeadPoints(float xBase, float yBase, float xPoint, float yPoint, float headToLengthRatio, float width){
        vecX=xPoint-xBase, vecY=yPoint-yBase; // the vector form the base to the point translated to the origin.
        float shaftLength=sqrt(powf(vecX,2.)+powf(vecY,2.));
        float theta=2*M_PI*.25; // Find the orthogonal unit vector
        float cosTheta=cos(theta), sinTheta=sin(theta);
        float unitX=vecX/shaftLength, unitY=vecY/shaftLength;
        float rotX=unitX*cosTheta-unitY*sinTheta, rotY=unitX*sinTheta+unitY*cosTheta;
        float orthX=rotX*width, orthY=rotY*width;
        xSide1=xPoint-vecX*headToLengthRatio+orthX; // find the arrow head side points based on the orthogonal unit vector to the shaft
        xSide2=xPoint-vecX*headToLengthRatio-orthX;
        ySide1=yPoint-vecY*headToLengthRatio+orthY;
        ySide2=yPoint-vecY*headToLengthRatio-orthY;
    }

public:
    CairoArrow(void) {
    }

    CairoArrow(cairo_t  *cr, float xBase, float yBase, float xPoint, float yPoint, float headToLengthRatio, float width, bool closed, bool filled) {
        draw(cr, xBase, yBase, xPoint, yPoint, headToLengthRatio, width, closed, filled);
    }

    void draw(cairo_t  *cr, float xBase, float yBase, float xPoint, float yPoint, float headToLengthRatio, float width, bool closed, bool filled) {
        findArrowHeadPoints(xBase, yBase, xPoint, yPoint, headToLengthRatio, width);
        cairo_move_to (cr, xBase, yBase); // start at the base and draw the shaft
        float scale=0.;
        if (closed|filled) // if closed, then just draw up to the arrow head
            scale=headToLengthRatio;
        cairo_line_to (cr, xBase+vecX*(1-scale), yBase+vecY*(1-scale));
        cairo_stroke (cr);
        // now draw the arrow head
        if (filled || closed) // close the path if filled or closed
            cairo_new_sub_path (cr);
        cairo_move_to (cr, xSide1, ySide1); // start at side1 and draw to the point, then side2
        cairo_line_to (cr, xPoint, yPoint);
        cairo_line_to (cr, xSide2, ySide2);
        if (filled || closed) // close the path if filled or closed
            cairo_close_path(cr);
        if (!filled)
            cairo_stroke (cr);
        else
            cairo_fill (cr);
    }

    virtual ~CairoArrow() {
    }
};

#endif // CAIROARROW_H_