propositiongraph.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 <qcombobox.h>
#include <qlineedit.h>
#include <qmessagebox.h>
#include <qpushbutton.h>
#include <qstatusbar.h>
#include <qstring.h>
#include <qtextedit.h>
#include <qwidgetstack.h>

#include "propositiongraph.hpp"
#include "parsers/graphml.hpp"
#include "parsers/dot.hpp"
#include "parsers/cat.hpp"
#include "edgelist.hpp"
#include "gui/buildpropositions.hpp"
#include "const.hpp"
#include "utils.hpp"

PropositionGraph::PropositionGraph()
    : Graph()
{
        init();
}

PropositionGraph::~PropositionGraph()
{
    //Noop
}

void PropositionGraph::deleteEdge(Edge* delEdge)
{
        // Make sure graph still connected
        if (delEdge->target()->incoming->count() >= 2 
                && delEdge->target()->outgoing->count() == 0)
        {
                gui->keywordsEdit->setText(QString("%1").arg(delEdge->target()->incoming->count()));
                delEdge->source()->outgoing->removeRef(delEdge);
                delEdge->target()->incoming->removeRef(delEdge);
                edges->removeRef(delEdge);
                delEdge->lineColor = QColor (255,0,0);
                useDot();
                
        }
        else 
        {
                QMessageBox::information( gui,"Modular Psi",
                QObject::tr("Deletion was not possible.\n"
                "Target node needs to be connected to the graph"));             
    }
        
}

void PropositionGraph::deleteProp(Proposition* delProp)
{
        // Make sure graph still connected
        if (delProp->outgoing->count() == 0 )
        {
                EdgeList::iterator ix = delProp->incoming->begin();
                // Ensure that selected don't point to a non-existing proposition
                if (propositionSelected() == operator[](delProp->name()))
                        setPropositionSelected(operator[]((*ix)->source()->name()));
        while ( ix != delProp->incoming->end()) {
                edges->removeRef(*ix);
                (*ix)->source()->outgoing->removeRef(*ix);
                ++ix;
                }
        delProp->incoming->clear();
                remove(delProp->name());
                //useDot();
                setChanged(true);
        }
        else 
        {
                QMessageBox::information( gui,"Modular Psi",
                QObject::tr("Deletion was not possible.\n"
                "Proposition have outgoing connections"));              
    }
}

void PropositionGraph::init()
{
        categories = new CategoryList;
}

QString PropositionGraph::newProposition()
{
    QString newName = QString("P%1").arg(lastName()+1);
    newProposition(newName);
    return newName;
}

void PropositionGraph::newProposition(QString newName)
{
    replace(newName, new Proposition(gui->props, newName));
    this->operator[](newName)->setName(newName);
    this->operator[](newName)->graph = this;
    checkLastName(newName);
    this->operator[](newName)->setCategoryId("na");
}

void PropositionGraph::newProposition (Proposition* father)
{
        QString newprop = newProposition();
        operator[](newprop)->setPublicName(Proposition::tr("New Proposition"));
        connect(father, operator[](newprop));
        useDot();
        setChanged(true);
} 

Edge* PropositionGraph::connect(QString source, QString target)
{    
    Node *s, *t;
    s = operator[](source);
    t = operator[](target);
    
    QString ss = s->name();
    QString st = t->name();
   Edge* e = new Edge (gui->props, s,t);
   e->setName(ss + "-" + st);
   edges->append(e);
   return e;
}

Edge* PropositionGraph::connect(Proposition* source, Proposition* target)
{
        return connect (source->name() , target->name());
}

Edge* PropositionGraph::connect(QString source, QString target, QString trust)
{
        Edge* e = connect (source, target);
        e->setTrust(trust);
        return e;
}

void PropositionGraph::load()
{
    
    // erase previous existing itens
    clear(); 
    edges->clear();
    clearAllEdges();
    
    loadCats();

    GraphML handler(this);
    QFile file("data/prop.graphml");
    QXmlSimpleReader reader;
    reader.setContentHandler(&handler);
    reader.setErrorHandler(&handler);
    reader.parse(&file);
    file.close();
    initComboCat();
    
    // Prevents previous invalid selections.
    if (count() > 0)
    setPropositionSelected(operator[]("P1"));
    
    useDot();
    setChanged(false);
}

void PropositionGraph::initComboCat()
{
        int i=0;
        gui->categorycombo->clear();
        QDictIterator<Category> ix( *categories );
    for( ; ix.current(); ++ix )
    {
        gui->categorycombo->insertItem(ix.current()->name(),i);
        ix.current()->setPosId(i);
        i++;
    }
}

void PropositionGraph::save(QString dir)
{
    GraphML handler(this);
    handler.save(dir);
    setChanged(false);
}

void PropositionGraph::useDot()
{
    Dot* d = new Dot(this);
    d->callDot();
    if (count() > 0) 
        BuildPropositions bp (gui,  this);
    gui->props->repaint();
}

void PropositionGraph::setPropositionSelected(Proposition* sel)
{
        gui->infoStack->raiseWidget(0);
        p_selected = sel;
        gui->nameEdit->setText(sel->publicName());
        gui->DescriptionEdit->setText(sel->description());
        gui->categorycombo->setCurrentItem(sel->cat->posId());
        gui->referencesEdit->setText(sel->references());
        gui->trustCombo->setCurrentItem( float2TrustItem(sel->trust()));
        gui->changeButton->setEnabled(false);
}

void PropositionGraph::setEdgeSelected(Edge* sel)
{
        gui->infoStack->raiseWidget(1);
        e_selected = sel;
        gui->edgeTrust->setCurrentItem( float2TrustItem(sel->trust()));
        gui->edgeSource->setText(sel->source()->publicName());
        gui->edgeTarget->setText(sel->target()->publicName());
}

void PropositionGraph::setInfo (short int inf)
{
        p_info = inf;
}

void PropositionGraph::setStatus(int stat)
{
        if (stat == STATUS_NOOP)
        {
                gui->setStatusText(Principal::tr("Ready"));
        } else if (stat == STATUS_NEWPROP)
        {
                gui->setStatusText(Principal::tr("Select Parent Proposition"));
        } else if (stat == STATUS_CONN_SOURCE)
        {
                gui->setStatusText(Principal::tr("Select Connection Source"));
        } else if (stat == STATUS_CONN_TARGET)
        {
                gui->setStatusText(Principal::tr("Select Connection Target"));
        } else if (stat == STATUS_EDGE_DELETE)
        {
                gui->setStatusText(Principal::tr("Select Connection to be Removed"));
        }
        
        p_status = stat;
}

void PropositionGraph::loadCats()
{
        Cat chandler(this);
    QFile cfile("data/cats.mpsi");
    QXmlSimpleReader creader;
    creader.setContentHandler(&chandler);
    creader.setErrorHandler(&chandler);
    creader.parse(&cfile);
    cfile.close();
}

void PropositionGraph::update()
{
        propositionSelected()->setPublicName(gui->nameEdit->text());
        propositionSelected()->setDescription(gui->DescriptionEdit->text());
        propositionSelected()->setReferences(gui->referencesEdit->text());
        propositionSelected()->setCategory(gui->categorycombo->currentText());
        setChanged(true);
}

void PropositionGraph::edgeUpdate()
{
        edgeSelected()->setTrust( trustItem2float(gui->edgeTrust->currentItem()));
        setChanged(true);
        useDot();
}