qetgraphicshandlerutility.cpp

Go to the documentation of this file.

/*
    Copyright 2006-2019 The QElectroTech Team
    This file is part of QElectroTech.

    QElectroTech 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.

    QElectroTech 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 should have received a copy of the GNU General Public License
    along with QElectroTech.  If not, see <http://www.gnu.org/licenses/>.
*/
#include "qetgraphicshandlerutility.h"
#include <QPainterPath>


QVector<QPointF> QetGraphicsHandlerUtility::pointsForRect(const QRectF &rect)
{
    QVector<QPointF> vector;
    QPointF point;
    vector << rect.topLeft();//*****Top left
    point = rect.center();
    point.setY(rect.top());
    vector << point;//**************Middle top
    vector << rect.topRight();//****Top right
    point = rect.center();
    point.setX(rect.left());
    vector << point;//**************Middle left
    point.setX(rect.right());
    vector << point;//**************Middle right
    vector << rect.bottomLeft();//**Bottom left
    point = rect.center();
    point.setY(rect.bottom());
    vector <<  point;//*************Middle bottom
    vector << rect.bottomRight();//*Bottom right
    return vector;
}

QVector<QPointF> QetGraphicsHandlerUtility::pointsForLine(const QLineF &line) {
    return (QVector<QPointF> {line.p1(), line.p2()});
}

QVector<QPointF> QetGraphicsHandlerUtility::pointsForArc(const QRectF &rect, qreal start_angle, qreal span_angle)
{
    QVector<QPointF> vector;
    QPainterPath path;
    path.arcTo(rect, start_angle, 0);
    vector.append(path.currentPosition());
    path.arcTo(rect, start_angle, span_angle);
    vector.append(path.currentPosition());
    return vector;

}

QRectF QetGraphicsHandlerUtility::rectForPosAtIndex(const QRectF &old_rect, const QPointF &pos, int index)
{
    if (index < 0 || index > 7) return old_rect;

    QRectF rect = old_rect;
    if (index == 0) rect.setTopLeft(pos);
    else if (index == 1) rect.setTop(pos.y());
    else if (index == 2) rect.setTopRight(pos);
    else if (index == 3) rect.setLeft(pos.x());
    else if (index == 4) rect.setRight(pos.x());
    else if (index == 5) rect.setBottomLeft(pos);
    else if (index == 6) rect.setBottom(pos.y());
    else if (index == 7) rect.setBottomRight(pos);

    return rect;
}

QRectF QetGraphicsHandlerUtility::mirrorRectForPosAtIndex(const QRectF &old_rect, const QPointF &pos, int index)
{
    if (index < 0 || index > 7) return old_rect;

    QRectF rect = old_rect;
    QPointF center = rect.center();

    if (index == 0) {
        qreal x = pos.x() + (pos.x() - rect.topLeft().x());
        qreal y = pos.y() + (pos.y() - rect.topLeft().y());
        rect.setTopLeft(QPointF(x,y));
    }
    else if (index == 1) {
        qreal y = pos.y() + (pos.y() - rect.topLeft().y());
        rect.setTop(y);
    }
    else if (index == 2) {
        qreal x = pos.x() + (pos.x() - rect.topRight().x());
        qreal y = pos.y() + (pos.y() - rect.topLeft().y());
        rect.setTopRight(QPointF(x,y));
    }
    else if (index == 3) {
        qreal x = pos.x() + (pos.x() - rect.left());
        rect.setLeft(x);
    }
    else if (index == 4) {
        qreal x = pos.x() + (pos.x() - rect.right());
        rect.setRight(x);
    }
    else if (index == 5) {
        qreal x = pos.x() + (pos.x() - rect.bottomLeft().x());
        qreal y = pos.y() + (pos.y() - rect.bottomLeft().y());
        rect.setBottomLeft(QPointF(x,y));
    }
    else if (index == 6) {
        qreal y = pos.y() + (pos.y() - rect.bottom());
        rect.setBottom(y);
    }
    else if (index == 7) {
        qreal x = pos.x() + (pos.x() - rect.bottomRight().x());
        qreal y = pos.y() + (pos.y() - rect.bottomRight().y());
        rect.setBottomRight(QPointF(x,y));
    }

    rect.moveCenter(center);
    return rect;
}

QLineF QetGraphicsHandlerUtility::lineForPosAtIndex(const QLineF &old_line, const QPointF &pos, int index) {
    QLineF line = old_line;
    index == 0 ? line.setP1(pos) : line.setP2(pos);
    return line;
}

QPolygonF QetGraphicsHandlerUtility::polygonForInsertPoint(const QPolygonF &old_polygon, bool closed, const QPointF &pos)
{
    qreal max_angle = 0;
    int index = 0;
    
    for (int i=1 ; i<old_polygon.size() ; i++)
    {
        QPointF A = old_polygon.at(i-1);
        QPointF B = old_polygon.at(i);
        QLineF line_a(A, pos);
        QLineF line_b(pos, B);
        qreal angle = line_a.angleTo(line_b);
        if(angle<180)
            angle = 360-angle;
        
        if (i==1)
        {
            max_angle = angle;
            index=i;
        }
        if (angle > max_angle)
        {
            max_angle = angle;
            index=i;
        }
    }
        //Special case when polygon is close
    if (closed)
    {
        QLineF line_a(old_polygon.last(), pos);
        QLineF line_b(pos, old_polygon.first());
        
        qreal angle = line_a.angleTo(line_b);
        if (angle<180)
            angle = 360-angle;
        
        if (angle > max_angle)
        {
            max_angle = angle;
            index=old_polygon.size();
        }
    }
    
    QPolygonF polygon = old_polygon;
    polygon.insert(index, pos);
    return polygon;
}

QVector<QPointF> QetGraphicsHandlerUtility::pointForRadiusRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode)
{
    QVector<QPointF> v;
    
    if(mode == Qt::AbsoluteSize)
    {
        QPointF X = rect.topRight();
        X.rx() -= xRadius;
        v << X;
        
        QPointF Y = rect.topRight();
        Y.ry() += yRadius;
        v << Y;
    }
    else
    {
        qreal half_width = rect.width()/2;
        qreal x_percent = std::min(xRadius, 100.00)/100;
        QPointF X(rect.right() - half_width*x_percent,
                  rect.top());
        v << X;
        
        qreal half_height = rect.height()/2;
        qreal y_percent = std::min(yRadius, 100.00)/100;
        QPointF Y(rect.right(),
                  rect.top()+ half_height*y_percent);
        v << Y;
    }
    
    return v;
}

qreal QetGraphicsHandlerUtility::radiusForPosAtIndex(const QRectF &rect, const QPointF &pos, int index, Qt::SizeMode mode)
{
    if (mode == Qt::AbsoluteSize)
    {
        if (index == 0)
        {
            QPointF tr = rect.topRight();
            qreal x = tr.x() - pos.x();
            if (x < 0) {
                x = 0;
            }
            else if (x > rect.width()/2) {
                x = rect.width()/2;
            }
            
            return x;
        }
        else if (index == 1)
        {
            QPointF tr = rect.topRight();
            qreal y = pos.y() - tr.y();
            if (y < 0) {
                y = 0;
            }
            else if (y > rect.height()/2) {
                y = rect.height()/2;
            }

            return y;
        }
        else {
            return 0;
        }
    }
    else
    {
        if(index == 0) //X
        {
            if (pos.x() < rect.center().x()) {
                return 100;
            }
            else if (pos.x() > rect.right()) {
                return 0;
            }
            else {
                return (100 - percentageInRange(rect.center().x(), rect.right(), pos.x()));
            }
        }
        else if (index == 1) //Y
        {
            if (pos.y() < rect.top()) {
                return 0;
            }
            else if (pos.y() > rect.center().y()) {
                return 100;
            }
            else {
                return percentageInRange(rect.top(), rect.center().y(), pos.y());
            }
        }
        else {
            return 0;
        }
    }
}

qreal QetGraphicsHandlerUtility::percentageInRange(qreal min, qreal max, qreal value) {
    return ((value - min) * 100) / (max - min);
}