edge.cpp

Go to the documentation of this file.

/*
 Modular Psi - A graph tracker of the Parapsychologcal scientific development
 Copyright (C) 2005 Leonardo Stern

 This program is free software; you can redistribute it and/or modify it under
 the terms of the Common Public License Version 1.0 or (at your option) any later version.

 This program 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 Common Public License for more details.

 You should have received a copy of the Common Public License along with this program;
*/


#include "const.hpp"
#include "edge.hpp"
#include "node.hpp"
#include "edgelist.hpp"
#include "propositiongraph.hpp"
#include "utils.hpp"
#include <qbitmap.h>
#include <qpainter.h>
#include <qstring.h>
#include <qwidgetstack.h>
#include <math.h>

Edge::Edge (QWidget* parent, Node* origem, Node* destino)  
    : QWidget ( parent, 0, 0 ) 
{
    init();
    setSource(origem);
    setTarget(destino);
    Edge* E = this;
    source()->outgoing->append(E);
    target()->incoming->append(E);  
}

Edge::~Edge()
{
    //NooP
}

void Edge::init()
{
    lineColor = QColor(0,0,0);
    propLineColor = lineColor;
    setAutoMask(true);
    setTrust((float)-1);
}

QString Edge::sourceName()
{
    return (QString) source()->name();  
}

QString Edge::targetName()
{
    return (QString) target()->name();  
}

void Edge::setChanged(bool alterado)
{
    p_changed = alterado;
}

void Edge::setTrust (float confianca )
{
    p_trust = confianca;
    setChanged(true);
    if (confianca >= 0) {
        lineColor = trust2rgb (confianca);
    } else lineColor = QColor(0,0,0);
    propLineColor = lineColor;
}

void Edge::setTrust (QString s_trust )
{
    setTrust((float)s_trust.toFloat());
}

void Edge::setCombinedTrust (float combined )
{
    p_combinedTrust = combined;
}

void Edge::setSource ( Node* origem ) 
{
    p_source = origem;
}

void Edge::setTarget ( Node* destino ) 
{
    p_target = destino;
}

void Edge::setStart ( QPoint inicio ) 
{
    p_start = inicio;
}

void Edge::setEnd ( QPoint fim )
{
    p_end = fim;
}
    
Node  Edge::opposite (Node* an_end) 
{
    if (source() == an_end )
        return target();
    return source();
}

void Edge::processBends()
{
    // initialize
    int L  = vNodes.at(0).x();
    int R = L;
    int U = vNodes.at(0).y();
    int D = U;
    QPoint ptemp;
    
    // FIXME
    for (unsigned int b1=0 ; b1 < vNodes.count(); b1++)
    {
                ptemp = vNodes.at(b1);
                if (ptemp.x() < L)
                        { L = ptemp.x(); } else
                if (ptemp.x() > R)
                        { R = ptemp.x(); }
                if (ptemp.y() < D) 
                        { D = ptemp.y(); } else
                if (ptemp.y() > U) 
                        { U = ptemp.y(); }
    }
    
    
    const int h = 10;
    const int l = 10;
    const int b = (h*h/(8*l) + l/2);
    
    QPoint C  = QPoint ( vNodes.at(vNodes.count()-1).x(), vNodes.at(vNodes.count()-1).y()); // fim do spline
    
    int dx = ( target()->center.x() - C.x() );
    int dy = ( target()->center.y() - C.y() );
    int d = (int)sqrt((long double)(dx*dx + dy*dy));
    
    QPoint O ( C.x() + b * ( dx / d ) , C.y() - b * ( dy / d ) );
    
    QPoint A ( - b * ( 0.866 * dy/d + 0.5 * dx / d ) + O.x() , 
        - b * ( 0.5 * dy/d - 0.866 * dx/d ) + O.y() );
        
    QPoint B (  b* ( 0.866 * dy/d - 0.5 * dx / d ) + O.x() , 
        - b * ( 0.5 * dy/d + 0.866 * dx/d ) + O.y() );
        
    arrowPoints.putPoints(0 ,3 , A.x(), A.y() , B.x(), B.y(), C.x() , C.y()) ; 
    DL = QPoint(L,D);

    for (unsigned int b2=0 ; b2 < arrowPoints.count(); b2++)
    {
                ptemp = arrowPoints.at(b2);
                if (ptemp.x() < L)
                        { L = ptemp.x(); } else
                if (ptemp.x() > R)
                        { R = ptemp.x(); }
                if (ptemp.y() < D) 
                        { D = ptemp.y(); } else
                if (ptemp.y() > U) 
                        { U = ptemp.y(); }
    }

    //update geometry
    //little dirty hack until the other bezier function arrives
    setGeometry(L, D+37, R-L, U-D );
    
    //global to local points
    for (unsigned int c=0 ; c < vNodes.count(); c++) {
        vNodes.putPoints ( c, 1, vNodes.at(c).x() - L , vNodes.at(c).y() - D);
    }
    for (unsigned int c1=0 ; c1 < arrowPoints.count(); c1++) {
        arrowPoints.putPoints ( c1, 1, arrowPoints.at(c1).x() - L , arrowPoints.at(c1).y() - D);
    }
}

void Edge::paintEvent (QPaintEvent*)
{
    QPainter painter(this);
    painter.setViewport(0,0,width() , height()  );
    draw(&painter);
}

void Edge::updateMask()
{
        QPainter painter;
        QBitmap mask(this->size(), TRUE);
        painter.begin(&mask);   
        painter.setPen(QPen((Qt::color1),4, SolidLine));
    for (unsigned int ab= 0 ; ab < (vNodes.count()/3); ab++)
    {
        painter.drawCubicBezier( vNodes , 3*ab ); 
    }

   painter.setBrush(SolidPattern);
   painter.drawPolygon(arrowPoints);

   setMask(mask);
}

void Edge::draw(QPainter* painter)
{


        painter->begin(this);
    painter->setPen(QPen(lineColor,1, SolidLine));
    // Bezier curves
    for (int co = 0 ; co < (vNodes.count()/3); co++)
    {
        painter->drawCubicBezier( vNodes , 3*co ); 
    }
   
    //Arrow
   painter->setBrush(QBrush(lineColor,SolidPattern));
   painter->drawPolygon(arrowPoints);
}

void Edge::changeActive( QColor thisColor)
{
        PropositionGraph *graph = ((Proposition*)source())->graph;
        lineColor = thisColor;
        repaint();
        if ( (graph->edgeSelected() != NULL)
                        && (graph->edgeSelected() != this))
                {
                        graph->edgeSelected()->lineColor = graph->edgeSelected()->propLineColor;
                        graph->edgeSelected()->repaint();
                }
        graph->setEdgeSelected(this);
}

void Edge::mousePressEvent (QMouseEvent *e)
{
        changeActive(COLOR_EDGE_SELECTED);
        PropositionGraph *graph = ((Proposition*)source())->graph;
        if (graph->status() == STATUS_EDGE_DELETE)
        {
                graph->deleteEdge(this);
        }
        repaint();
}