/home/enzo/treballs/fib/pfc/nanocomp/src/mainController.cpp

Go to the documentation of this file.

/*
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 *   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         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
                                                                          */

// $Revision: 1.16 $
 
#include "mainController.hpp"
#include <wx/filename.h>

 MainController::MainController()
 {
    initControllers();
    fileName = wxEmptyString;
 }


MainController::~MainController()
{
    delete rules;
    delete layouts;
    delete forbiddenPatterns;
    delete truthTables;  
}



 void MainController::setNanoFrame(NanoFrame *frame)
 {
    this->frame = frame;
 }



NanoFrame* MainController::getNanoFrame()
 {
    return frame;
 }



void MainController::setRules(RuleManager *rules)
{
    this->rules = rules;
}



void MainController::setLayouts(LayoutManager *layouts)
{
    this->layouts = layouts;
}



void MainController::setForbiddenPatterns(ForbiddenPatternManager *forbiddenPatterns)
{
    this->forbiddenPatterns = forbiddenPatterns;
}



void MainController::setTruthTables(TruthTableManager *truthTables)
{
    this->truthTables = truthTables;
}


void MainController::initControllers()
{
    rules = new RuleManager(this);
    forbiddenPatterns = new ForbiddenPatternManager(this);
    truthTables = new TruthTableManager(this);
    layouts = new LayoutManager(this, truthTables, forbiddenPatterns, rules);
    simulation = new SimulationManager(this, truthTables, forbiddenPatterns, rules, layouts);
}



RuleManager* MainController::getRules()
{
    return rules;    
}



LayoutManager* MainController::getLayouts()
{
    return layouts;
}



ForbiddenPatternManager* MainController::getForbiddenPatterns()
{
    return forbiddenPatterns;
}



TruthTableManager* MainController::getTruthTables()
{
    return truthTables;
}


void MainController::tablesChanged()
{
    layouts->tablesChanged();
}


void MainController::FPsChanged()
{
    layouts->FPsChanged();
}


void MainController::rulesChanged()
{
    layouts->rulesChanged();
}



void MainController::setStatusMessage(wxString message)
{
    frame->setStatusMessage(message);
}


//TODO: check the path of all filenames since they all must be saved
//in the same directory to work
//So we'll have to change the order of file asking or something

void MainController::save()
{
   if (rules->saveFile() && forbiddenPatterns->saveFile() && truthTables->saveFile() && layouts->saveFile())
    {
        if (fileName == wxEmptyString)
        {
            wxString name = fileView.saveFileChoose(frame, _("Select a project file to save"), _("*.ncp"));
    
            if (name != wxEmptyString)
            {
                fileName = name;
            }
            else
            {
                return;
            }
        }
        //Here we save all files again in the same directory as the project
        //TODO: check errors
        wxFileName path(fileName);
        wxString pPath = path.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
        wxFileName ruleFile(rules->getFileName());
        wxFileName FPFile(forbiddenPatterns->getFileName());
        wxFileName tableFile(truthTables->getFileName());
        wxFileName layoutFile(layouts->getFileName());
        
        rules->saveFilename(pPath + ruleFile.GetFullName());
        forbiddenPatterns->saveFilename(pPath + FPFile.GetFullName());
        truthTables->saveFilename(pPath + tableFile.GetFullName());
        layouts->saveFilename(pPath + layoutFile.GetFullName());
        
        wxFileName extension(fileName);
        extension.SetExt(_("ncp"));
        fileName = extension.GetFullPath();
        wxFileOutputStream fileStream(fileName);
        wxTextOutputStream *outStream = new wxTextOutputStream(fileStream);
        saveFileNames(outStream);
        saveTables(outStream);
        saveRules(outStream);
        savePatterns(outStream);
        delete outStream;
        frame->setTitleBar(fileName);
    }
}


void MainController::saveAs()
{
if (rules->saveFile() && forbiddenPatterns->saveFile() && truthTables->saveFile() && layouts->saveFile())
    {
        wxString name = fileView.saveFileChoose(frame, _("Select a project file to save"), _("*.ncp"));

        if (name != wxEmptyString)
        {
            fileName = name;
        }
        else
        {
            return;
        }
    }
    //Here we save all files again in the same directory as the project
    //TODO: check errors
    wxFileName path(fileName);
    wxString pPath = path.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
    wxFileName ruleFile(rules->getFileName());
    wxFileName FPFile(forbiddenPatterns->getFileName());
    wxFileName tableFile(truthTables->getFileName());
    wxFileName layoutFile(layouts->getFileName());
    
    rules->saveFilename(pPath + ruleFile.GetFullName());

    forbiddenPatterns->saveFilename(pPath + FPFile.GetFullName());

    truthTables->saveFilename(pPath + tableFile.GetFullName());

    layouts->saveFilename(pPath + layoutFile.GetFullName());
    
    wxFileName extension(fileName);
    extension.SetExt(_("ncp"));
    fileName = extension.GetFullPath();
    wxFileOutputStream fileStream(fileName);
    wxTextOutputStream *outStream = new wxTextOutputStream(fileStream);
    saveFileNames(outStream);
    saveTables(outStream);
    saveRules(outStream);
    savePatterns(outStream);
    delete outStream;
    frame->setTitleBar(fileName);
}


void MainController::open()
{
    //First we ask for saving the project if some part
    //has been modified
    if (rules->isModified() || 
        forbiddenPatterns->isModified() ||
        truthTables->isModified() ||
        layouts->isLayoutModified())
    {
        save();
    }
    
    //Reset collections
    rules->clean();
    forbiddenPatterns->clean();
    truthTables->clean();
    layouts->clean();
    
    wxString name = fileView.openFileChoose(frame, _("Select a project file to open"), _("*.ncp"));
    
    if (name != wxEmptyString)
    {
        fileName = name;
    }
    else
    {
        return;
    }
    
    if (!openFile(fileName))
    {
        //Clean
        rules->clean();
        forbiddenPatterns->clean();
        truthTables->clean();
        layouts->clean();
        frame->setTitleBar(fileName);
        fileName = wxEmptyString;
        frame->setTitleBar(_("Untitled"));
    }
    else
    {
        frame->setTitleBar(fileName);
    }
}



void MainController::newFile()
{
    //Save 
    save();
    
    //New
    fileName = wxEmptyString;
    rules->clean();
    forbiddenPatterns->clean();
    truthTables->clean();
    layouts->clean();
    frame->setTitleBar(_("Untitled"));
}



void MainController::saveFileNames(wxTextOutputStream *stream)
{
        *stream << _("rules=") << wxFileName(rules->getFileName()).GetFullName() << endl;
        *stream << _("fps=") << wxFileName(forbiddenPatterns->getFileName()).GetFullName() << endl;
        *stream << _("tables=") << wxFileName(truthTables->getFileName()).GetFullName() << endl;
        *stream << _("layout=") << wxFileName(layouts->getFileName()).GetFullName() << endl;
}



void MainController::saveTables(wxTextOutputStream *stream)
{
    map< wxString, vector<coordinate> >  tableInputs = layouts->getTableInputs();
    map< wxString, vector<coordinate> > tableOutputs = layouts->getTableOutputs();
    map< wxString, bool> tableEnabled = layouts->getTableEnabled();
    
    //Save all table information
    for (map< wxString, bool>::iterator i = tableEnabled.begin(); i != tableEnabled.end(); i++)
    {
        wxString table = (*i).first;
        //Name
        *stream << table << endl;
        //Enabled/disabled
        if ((*i).second)
        {
            *stream << 1 << endl;
        }
        else
        {
            *stream << 0 << endl;
        }
        //Inputs
        vector<coordinate> inputs = tableInputs[table];
        for (unsigned int j = 0; j < inputs.size(); j++)
        {
            *stream << inputs[j].x << endl << inputs[j].y << endl;
        }
        
        //Outputs
        vector<coordinate> outputs = tableOutputs[table];
        for (unsigned int j = 0; j < outputs.size(); j++)
        {
            *stream << outputs[j].x << endl << outputs[j].y << endl;
        }
    }
}



void MainController::saveRules(wxTextOutputStream *stream)
{
    map< unsigned int, bool> ruleEnabled = layouts->getRuleEnabled();
    for (map< unsigned int, bool>::iterator i = ruleEnabled.begin(); i != ruleEnabled.end(); i++)
    {
        *stream << (*i).first << endl << (*i).second << endl;
    }
}



void MainController::savePatterns(wxTextOutputStream *stream)
{
    map< unsigned int, bool> FPEnabled = layouts->getFPEnabled();
    for (map< unsigned int, bool>::iterator i = FPEnabled.begin(); i != FPEnabled.end(); i++)
    {
        *stream << (*i).first << endl << (*i).second << endl;
    }
}



bool MainController::openFile(wxString file)
{
    bool result;
    wxFileName path(file);
    wxString pPath = path.GetPath(wxPATH_GET_VOLUME | wxPATH_GET_SEPARATOR);
    
    wxFileInputStream *fileStream = new wxFileInputStream(file);
    wxTextInputStream *inStream = new wxTextInputStream(*fileStream);
    
    wxString tempFile;
    wxString line;
    
    //Rules
    line = inStream->ReadLine();
    //TODO: look another way to do this
    if (fileStream->LastRead() == 0 || fileStream->Eof())
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening rule file."));
        return false;
    }
    if (!line.StartsWith(_("rules="), &tempFile))
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening rule file."));
        return false;
    }
    else
    {
        if (!tempFile.IsEmpty())
        {
            result = rules->openPFile(pPath + tempFile);
            if (!result)
            {
                frame->errorMsg(_("Error opening rule file."));
                return false;
            }
        }
    }
    
    //Patterns
    line = inStream->ReadLine();
    if (fileStream->LastRead() == 0 || fileStream->Eof())
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening pattern file."));
        return false;
    }
    if (!line.StartsWith(_("fps="), &tempFile))
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening pattern file."));
        return false;
    }
    else
    {
        if (!tempFile.IsEmpty())
        {
            result = result && forbiddenPatterns->openPFile(pPath + tempFile);
            if (!result)
            {
                frame->errorMsg(_("Error opening forbidden pattern file."));
                return false;
            }
        }
    }
    
    //Truth Tables
    line = inStream->ReadLine();
    if (fileStream->LastRead() == 0 || fileStream->Eof())
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening table file."));
        return false;
    }
    if (!line.StartsWith(_("tables="), &tempFile))
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening table file."));
        return false;
    }
    else
    {
        if (!tempFile.IsEmpty())
        {
            result = result && truthTables->openPFile(pPath + tempFile);
            if (!result)
            {
                frame->errorMsg(_("Error opening truth table file."));
                return false;
            }
        }
    }
    
    //Layout
    line = inStream->ReadLine();
    if (fileStream->LastRead() == 0 || fileStream->Eof())
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening layout file."));
        return false;
    }
    if (!line.StartsWith(_("layout="), &tempFile))
    {
        //ERROR
        //TODO: when error "clean" all project
        frame->errorMsg(_("Error opening layout file."));
        return false;
    }
    else
    {
        if (!tempFile.IsEmpty())
        {
            result = result && layouts->openPFile(pPath + tempFile);
            if (!result)
            {
                frame->errorMsg(_("Error opening layout file."));
                return false;
            }
        }
    }
    
    //Tables
    if (!openTables(fileStream, inStream))
    {
        frame->errorMsg(_("Error mapping tables."));
        result = false;
    }
    else
    {
        result = result && true;
    }
    
    //Rules
    if (!openRules(fileStream, inStream))
    {
        frame->errorMsg(_("Error mapping rules."));
        result = false;
    }
    else
    {
        result = result && true;
    }
    //Patterns
    if (!openFPs(fileStream, inStream))
    {
        frame->errorMsg(_("Error mapping patterns."));
        result = false;
    }
    else
    {
        result = result && true;
    }
    
    return result;
}



bool MainController::openTables(wxFileInputStream *fileStream, wxTextInputStream *inStream)
{
    wxString table;
    wxString temp;
    long int iTemp;
    bool enabled;
    long int x;
    long int y;
    
    for (int i = 0; i < layouts->getTables(); i++)
    {
        table = inStream->ReadLine();
        if (fileStream->LastRead() == 0 || fileStream->Eof())
        {
            return false;
        }
        //We've read a table name, proceed to see if enabled or not
        temp = inStream->ReadLine();
        if (fileStream->LastRead() == 0 || fileStream->Eof())
        {
            return false;
        }
        if (!temp.ToLong(&iTemp))
        {
            return false;
        }
        
        if (iTemp == 0)
        {
            enabled = false;
        }
        else if (iTemp == 1)
        {
            enabled = true;
        }
        else
        {
            return false;
        }
        
        layouts->tableChecked(table, enabled);
        //Inputs
        for (int j = 0; j < truthTables->getInputs(table); j++)
        {
            temp = inStream->ReadLine();
            if (fileStream->LastRead() == 0 || fileStream->Eof())
            {
                return false;
            }
            if (!temp.ToLong(&x))
            {
                return false;
            }
            temp = inStream->ReadLine();
            if (fileStream->LastRead() == 0 || fileStream->Eof())
            {
                return false;
            }
            if (!temp.ToLong(&y))
            {
                return false;
            }
            if (!layouts->setInput(table, j, x, y))
            {
                return false;
            }
        }
        
        //Outputs
        for (int j = 0; j < truthTables->getOutputs(table); j++)
        {
            temp = inStream->ReadLine();
            if (fileStream->LastRead() == 0 || fileStream->Eof())
            {
                return false;
            }
            if (!temp.ToLong(&x))
            {
                return false;
            }
            temp = inStream->ReadLine();
            if (fileStream->LastRead() == 0 || fileStream->Eof())
            {
                return false;
            }
            if (!temp.ToLong(&y))
            {
                return false;
            }
            if (!layouts->setOutput(table, j, x, y))
            {
                return false;
            }
        }
    }
    return true;
}



bool MainController::openRules(wxFileInputStream *fileStream, wxTextInputStream *inStream)
{
    wxString temp;
    long int iTemp;
    bool enabled;
    unsigned long int rule;
    
    for (int i = 0; i < layouts->getRules(); i++)
    {
        temp = inStream->ReadLine();
        if (fileStream->LastRead() == 0 || fileStream->Eof())
        {
            return false;
        }
        if (!temp.ToULong(&rule))
        {
            return false;
        }
        temp = inStream->ReadLine();
        if (fileStream->LastRead() == 0 || fileStream->Eof())
        {
            return false;
        }
       if (!temp.ToLong(&iTemp))
        {
            return false;
        }
        
        if (iTemp == 0)
        {
            enabled = false;
        }
        else if (iTemp == 1)
        {
            enabled = true;
        }
        else
        {
            return false;
        }
        layouts->ruleChecked(rule, enabled);
    }
        return true;
}



bool MainController::openFPs(wxFileInputStream *fileStream, wxTextInputStream *inStream)
{
    wxString temp;
    long int iTemp;
    bool enabled;
    unsigned long int fp;
    
    for (int i = 0; i < layouts->getFPs(); i++)
    {
        temp = inStream->ReadLine();
        if (fileStream->LastRead() == 0 || fileStream->Eof())
        {
            return false;
        }
        if (!temp.ToULong(&fp))
        {
            return false;
        }
        temp = inStream->ReadLine();
        if (fileStream->LastRead() == 0 || fileStream->Eof())
        {
            return false;
        }
       if (!temp.ToLong(&iTemp))
        {
            return false;
        }
        
        if (iTemp == 0)
        {
            enabled = false;
        }
        else if (iTemp == 1)
        {
            enabled = true;
        }
        else
        {
            return false;
        }
        layouts->FPChecked(fp, enabled);
    }
    return true;
}


void MainController::startSimulation()
{
    simulation->prepareSimulation();
    setStatusMessage(_("Simulation in progress"));
}


void MainController::prepareSimulation()
{
    if (!rules->checkRules())
    {
        frame->errorMsg(_("Check Rules for errors"));
    }
    else if (!forbiddenPatterns->checkPatterns())
    {
        frame->errorMsg(_("Check Forbidden Patterns for errors"));
        setStatusMessage(_("Check Forbidden Patterns for errors"));
    }
    else if (!layouts->checkLayout())
    {
        frame->errorMsg(_("Check there is a truth table checked and it has its inputs and outputs assigned"));
        setStatusMessage(_("Check there is a truth table checked and it has its inputs and outputs assigned"));
    }
    else
    {
        layouts->enableSimulation();
        setStatusMessage(_("Ready to simulate"));
    }
}


void MainController::elementChanged()
{
    layouts->elementChanged();
}

---