C:/CVUT/diplomka/Automata_editor/sources/transitionVCurve.cpp

Go to the documentation of this file.

#include "constants.h"

#include "transitionVCurve.h"
#include "state.h"
#include "label.h"
#include "transforms.h"

#include <math.h>

#include <QtDebug>

TransitionVCurve::TransitionVCurve(Editor *parent, State *ss, State *es,
                                   const QString &labelText, bool left, bool dimmed)
: TwoStatesTransition(parent, ss, es, left, dimmed),
  arcangle(DEF_VCURV_ANGLE),
  arcangleB(left ? DEF_VCURV_ANGLE_B : DEF_VCURVR_ANGLE_B),
  ncurv(DEF_VCURV_CURV)
{
  setZValue(Z_TRANSITION);
  label = new LabelX(this, labelText, leftOriented, m_labelFontSize,
        dimmed ? QColor(dimEdgeLabelColor) : QColor(edgeLabelColor));
  label->setZValue(Z_TR_LABEL);
  label->setPosParam(DEF_ARC_LAB_POS);
  adjust();
  setLabelPosition();
}

TransitionVCurve::~TransitionVCurve()
{
    DBGLOG("called");
}

void TransitionVCurve::adjust()
{
    prepareGeometryChange();
    if (!startState || !endState) return;

    QPolygonF anglePol, statePol, iPol;
    anglePol << startState->pos() << startState->pos() + QPointF(cos(M_PI/180*arcangle), -sin(M_PI/180*arcangle))*startState->getWidth();
    statePol << mapFromItem(startState, startState->getMyPolygon());
    iPol = (findIntersectedPoints(anglePol, statePol, eFIND_FIRST));
    if (iPol.empty())
    {
        qWarning("TransitionVCurve::adjust -> startPoint is set to startState->pos()!");
        startPoint = startState->pos();
    }
    else
    {
        startPoint = iPol[0];
    }

    anglePol.clear();
    statePol.clear();
    anglePol << endState->pos() << endState->pos() + QPointF(cos(M_PI/180*arcangleB), -sin(M_PI/180*arcangleB))*endState->getWidth();
    statePol << mapFromItem(endState, endState->getMyPolygon());
    iPol = (findIntersectedPoints(anglePol, statePol, eFIND_FIRST));
    if (iPol.empty())
    {
        qWarning("TransitionVCurve::adjust -> endPoint is set to endState->pos()!");
        endPoint  = endState->pos();
    }
    else
    {
        endPoint = iPol[0];
    }

    if (startPoint == endPoint)
    {
        setLabelPosition();
        return;
    }
  
    QPainterPath path;
  
    QLineF s_v(startPoint, endPoint);
    float len = s_v.length()/2;

    float angleA, angleB; // left or right orientation
    angleA = arcangle;
    angleB = arcangleB;
  
    float x,y;  // compute vector from start point
    x = cos(M_PI/180*(angleA));
    y = sin(M_PI/180*(angleA)); // compute new unitVector
    QPointF point = QPointF(x,-y); 
    point += startPoint; // place to startPoint
  
    QLineF a_v(startPoint,point); // vector from startPoint
  
    // now compute vector from end point
    x = cos(M_PI/180*(angleB));
    y = sin(M_PI/180*(angleB)); // compute new unitVector
    point = QPointF(x,-y); 
    point += endPoint; // place to endPoint
      
    QLineF b_v(s_v.p2(),point); // vector from endPoint

    // set length by ncurv
    float current_ncurv = len * ncurv; // experiment
    a_v.setLength(current_ncurv);
    b_v.setLength(current_ncurv);

    a_point = a_v.p2(); b_point = b_v.p2();
    path.moveTo(startPoint);
    path.cubicTo(a_point, b_point, endPoint);

    p = path;
  
    QList<QPolygonF> pathList = p.toSubpathPolygons();
    if (pathList.size() > 1)
        RELLOG("not only one sub-path polygon!");
    
    iPol = pathList[0]; // endPoint is on state's polygon, so it may be no intersected
    iPol << endState->pos();
    
    pa = getArrowPolygon(p);
    
    setLabelPosition();
    createStrokes(p);
}

void TransitionVCurve::setLabelPosition()
{
    if (label)
    { 
        Transition::setLabelPosition(label, label->posParam(), leftOriented, label->getWidth(), label->getHeight());
    } // if
    Transition::setLabelPosition();
}

QString TransitionVCurve::getTypeName() const
{
    return "VCurve";
}

/*void TransitionVCurve::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
    if (startPoint == endPoint)     
        return;    

    QColor lineC;
    Qt::PenStyle lineS;
  
    if (dimmed)
    {
        lineS = dimEdgeLineStyle;
        lineC = dimEdgeLineColor;
    } 
    else
    {
        lineS = edgeLineStyle;
        lineC = edgeLineColor;
    }
  
    if (checked)    
        painter->setPen(QPen(checkedColor, m_lineWidth, lineS));    
    else
        painter->setPen(QPen(lineC, m_lineWidth, lineS));

    painter->setBrush(Qt::NoBrush);
    painter->strokePath(p, painter->pen());
 

    // arrow
    if (checked)
        painter->setBrush(checkedColor);
    else
        painter->setBrush(lineC);

    painter->drawPolygon(pa); // computed in adjust

    paintSelectionDecoration(painter);

#ifdef TESTING_PAINTING
#   ifdef TESTING_BOUNDING_RECT_PAINTING
        painter->setBrush(QBrush(QColor(50,255,0,100)));
        painter->fillRect(boundingRect(), painter->brush());
#   endif

    painter->setBrush(QBrush(QColor(0,0,255,150)));
    painter->fillPath(shape(), painter->brush());      
#endif
}*/

QString TransitionVCurve::getVCCommand() const
{
    QString command = "\\";

    command += getTypeName();
    command += getTypeNameSuffix();
      
    float def_vcurv_angle_b = (getTypeNameSuffix() == "L") ? DEF_VCURV_ANGLE_B : DEF_VCURVR_ANGLE_B;
    
    Q_ASSERT(label != NULL);
    if (label->posParam() != DEF_ARC_LAB_POS) 
        command += QString("[%1]").arg(label->posParam());
      
    command += "{";        
    if (getArcAngle() != (int)DEF_VCURV_ANGLE)
        command += QString("angleA=%1").arg(getArcAngle());
    if (getArcAngleB() != def_vcurv_angle_b)
    {
        if (getArcAngle() != (int)DEF_VCURV_ANGLE)
            command += ",";
        command += QString("angleB=%1").arg(getArcAngleB());
    }
    if (getNCurv() != (float)DEF_VCURV_CURV)
    {
        if (getArcAngle() != (int)DEF_VCURV_ANGLE ||
            getArcAngleB() != def_vcurv_angle_b)
            command += ",";
        command += QString("ncurv=%1").arg(getNCurv());
    }
    command += "}";
    
    command += "{" + startState->getName() + "}";
    command += "{" + endState->getName() + "}";

    command += "{" + label->text() + "}";

    command += getNextLabelsVCCommand();

    return command;
}

QString TransitionVCurve::getGraphMLParams() const
{
    QString params = "";
    
    if (arcangle != DEF_VCURV_ANGLE)
    {
        params += QString("      <data key=\"d131\">%1</data>\n")
                    .arg(getArcAngle());
    }
    if (arcangleB != DEF_VCURV_ANGLE_B)
    {
        params += QString("      <data key=\"d132\">%1</data>\n")
                    .arg(getArcAngle());
    }
    if (ncurv != DEF_VCURV_CURV)
    {
        params += QString("      <data key=\"d133\">%1</data>\n")
                    .arg(getNCurv());
    }

    return params;
}

/*
// export
QString TransitionVCurve::getEPS() const
{
    QString s = "";
  
    QColor lineC;
    Qt::PenStyle lineS;
  
    int r, g, b; float rf, gf, bf;
  
    if (dimmed)
    {
        lineS = dimEdgeLineStyle;
        lineC = dimEdgeLineColor;
    }
    else
    {
        lineS = edgeLineStyle;
        lineC = edgeLineColor;
    }
  
    lineC.getRgb(&r,&g,&b);
    rf = r / 255.; gf = g / 255.; bf = b / 255.;
    // % r g b width x0 y0 x1 y1 x2 y2 x y trVCurve
    s += trLineStyle(lineS);
    s += QString(" %1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 trVCurve\n")
         .arg(rf).arg(gf).arg(bf)
         .arg(m_lineWidth)
         .arg(a_point.x()).arg(scene()->height()-2 - a_point.y())
         .arg(b_point.x()).arg(scene()->height()-2 - b_point.y())
         .arg(endPoint.x()).arg(scene()->height()-2 - endPoint.y())
         .arg(startPoint.x()).arg(scene()->height()-2 - startPoint.y());
  
    s += Transition::getEPS();   // nakonec se vykresli label
  
    return s;
}
*/