/home/enzo/treballs/fib/pfc/nanocomp/src/forbiddenPatternManager.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.19 $

#include "forbiddenPatternManager.hpp"
#include <wx/filename.h>



ForbiddenPatternManager::ForbiddenPatternManager(MainController *controller)
{
    nextId = 1;
    currentFP = 0; //No FP
    modified = false;
    needNewFile = false;
    fileName = wxEmptyString;
    diskManager = new ForbiddenPatternDiskManager(this);
    this->controller = controller;
}


ForbiddenPatternManager::~ForbiddenPatternManager()
{
    delete diskManager;
}



void ForbiddenPatternManager::setView(ForbiddenPatternView *view)
{
    this->view = view;
}



void ForbiddenPatternManager::cellChanged(int x, int y)
{
    FPList[currentFP]->cellChanged(x,  y);
    updateGrids(false);
    modified = true;
    controller->elementChanged();
}



void ForbiddenPatternManager::updateGrids(bool changed)
{
    Grid grid;
    if (currentFP > 0)
    {
        grid = FPList[currentFP]->getGrid();
    }
    view->updateGrids(grid, changed); 
}



void ForbiddenPatternManager::newFP(int width, int height)
{
    ForbiddenPattern *newFP = new ForbiddenPattern(width, height);
    //Add the pattern to the collection
    FPList[nextId] = newFP;
    //Assign the new pattern as the selected one
    currentFP = nextId;
    nextId++;
    //Update the view because of the new selection
    view->updateGrids(newFP->getGrid(), true);
    updateList();
    view->selectFP(currentFP);
    FPSelected(currentFP);
    if (fileName == wxEmptyString)
    {
        needNewFile = true;
    }
    modified = true;
    //Notify the controller that the patterns have changed
    controller->FPsChanged();
    controller->elementChanged();
}


void ForbiddenPatternManager::updateList()
{
    wxArrayString stringList;
    for (map<unsigned int, ForbiddenPattern*>::iterator i = FPList.begin(); i != FPList.end(); i++)
    {
        stringList.Add(wxString::Format(_("Pattern %d"), (*i).first));
    }
    view->updateList(stringList);
}


void ForbiddenPatternManager::FPSelected(unsigned int FPId)
{
    currentFP = FPId;
    updateGrids(true);
}


void ForbiddenPatternManager::removeFP()
{
    //Delete the pattern
    delete FPList[currentFP];
    //Here we choose the new selected pattern
    map<unsigned int, ForbiddenPattern*>::iterator i = FPList.find(currentFP);
    bool first = (i == FPList.begin());
    //Create two iterators because we have to delete an element
    //pointed by this one and then the iterator comes invalid
    map<unsigned int, ForbiddenPattern*>::iterator j = i;
    map<unsigned int, ForbiddenPattern*>::iterator k = i;
    j++;
    k--;
    FPList.erase(i);
    if (j != FPList.end())
    {
        currentFP = (*j).first;
    }
    else
    {
        //We deleted the only pattern left
        if (first)
        {
            currentFP = 0;//No FPs
        }
        else
        {
            currentFP = (*k).first;
        }
    } 
    //Update view
    updateList();
    view->selectFP(currentFP);
    FPSelected(currentFP);
    modified = true;
    //Notify main controller that patterns have changed
    controller->FPsChanged();
    controller->elementChanged();
}



bool ForbiddenPatternManager::saveFile()
{
    if (modified)
    {
        if (needNewFile)
        {
            wxString name = fileView.saveFileChoose(view, _("Select a forbidden pattern file to save"), _("*.rule"));
    
            if (name != wxEmptyString)
            {
                fileName = name;
            }
            else
            {
                return false;
            }
        }
    
        list<ForbiddenPattern*> FPs;
    
        for(map<unsigned int, ForbiddenPattern*>::iterator i = FPList.begin(); i != FPList.end(); i++)
        {
            FPs.push_back((*i).second);
        }
        
        //Set the extension for the filename
        wxFileName extension(fileName);
        extension.SetExt(_("rule"));
        fileName = extension.GetFullPath();
        if (diskManager->saveFPs(FPs, fileName))
        {
            modified = false;
            needNewFile = false;
        }
        else
        {
            view->errorMsg(_("Error saving forbidden pattern file!"));
            return false;
        }
    }
    return true;
}



bool ForbiddenPatternManager::saveFileAs()
{
    wxString name = fileView.saveFileChoose(view, _("Select a forbidden pattern file to save"), _("*.rule"));
    
    if (name != wxEmptyString)
    {
        fileName = name;
    }
    else
    {
        return false;
    }
    
    list<ForbiddenPattern*> FPs;
  
    for(map<unsigned int, ForbiddenPattern*>::iterator i = FPList.begin(); i != FPList.end(); i++)
    {
        FPs.push_back((*i).second);
    }
   
    //Set the extension for the filename
    wxFileName extension(fileName);
    extension.SetExt(_("rule"));
    fileName = extension.GetFullPath();
    if (diskManager->saveFPs(FPs, fileName))
    {
        modified = false;
        needNewFile = false;
    }
    else
    {
        view->errorMsg(_("Error saving forbidden pattern file!"));
        return false;
    }
    return true;
}



void ForbiddenPatternManager::openFile()
{
    bool deleteFPs = false;
    //We should ask if the user wants to replace
    //the FPs or if he wants to append them to
    //existing
    if (FPList.size() > 0)
    {
        if (!view->msgYesNo(_("Do you want to append the new forbidden patterns into the existing ones? (Selecting no will delete them)")))
        {
            deleteFPs = true;
            //We have to delete existing FPs
            //Check if the user wants to save modified FPs
            if (modified)
            {
                if (view->msgYesNo(_("Do you want to save modified forbidden patterns?")))
                {
                    saveFile();
                }
            }
        }
        else
        {
            deleteFPs = false;
        }
        
        if (!appendFPs(deleteFPs, false))
        {
            view->errorMsg(_("Error opening forbidden pattern file"));
            clean();
        }
    }
    else
    {
        if (!appendFPs(deleteFPs, true))
        {
            view->errorMsg(_("Error opening forbidden pattern file"));
            clean();
        }
    }
    controller->elementChanged();
}


void ForbiddenPatternManager::deleteFPs()
{
    FPList.clear();
    nextId = 1;
    currentFP = 0; //No current FP
    controller->elementChanged();
}



bool ForbiddenPatternManager::openPFile(wxString file)
{
    bool result;
    fileName = file;
    deleteFPs();
    result = diskManager->openFPs(file);
    updateList();
    view->selectFP(currentFP);
    FPSelected(currentFP);
    controller->elementChanged();
    return result;
}



bool ForbiddenPatternManager::appendFPs(bool mustDeleteFPs, bool newFile)
{
    bool result;
    wxString name =fileView.openFileChoose(view, _("Select a forbidden pattern file to open"), _("*.rule"));
    
    if (name != wxEmptyString)
    {
        if (mustDeleteFPs)
        {
            deleteFPs();
        }
        //Set te new filename if necessary
        if (newFile)
        {
            fileName = name;
        }
        
        result = diskManager->openFPs(name);
    }
    
    updateList();
    view->selectFP(currentFP);
    FPSelected(currentFP);
    modified = true;
    
    controller->elementChanged();
    return result;    
}



void ForbiddenPatternManager::newFP(ForbiddenPattern *fp)
{
    FPList[nextId] = fp;
    currentFP = nextId;
    nextId++;
    modified = true;
    controller->FPsChanged();
    controller->elementChanged();
}



wxArrayString ForbiddenPatternManager::getFPList()
{
    wxArrayString result;
    
    for (map<unsigned int, ForbiddenPattern*>::iterator i = FPList.begin(); i != FPList.end(); i++)
    {
        result.Add(wxString::Format(_("Pattern %d"), (*i).first));
    }
    
    return result;  
}



bool ForbiddenPatternManager::isModified()
{
    return modified;
}



wxString ForbiddenPatternManager::getFileName()
{
    return fileName;
}



bool ForbiddenPatternManager::saveFilename(wxString file)
{
    list<ForbiddenPattern*> FPs;
    for(map<unsigned int, ForbiddenPattern*>::iterator i = FPList.begin(); i != FPList.end(); i++)
        {
            FPs.push_back((*i).second);
        }
        
        if (diskManager->saveFPs(FPs, file))
        {
            fileName = file;
            return true;
        }
        else
        {
            return false;
        }
}



void ForbiddenPatternManager::clean()
{
    fileName = wxEmptyString;
    deleteFPs();
    updateList();
    view->selectFP(currentFP);
    FPSelected(currentFP);
    controller->FPsChanged();
    controller->elementChanged();
    modified = false;
}



bool ForbiddenPatternManager::checkPatterns()
{
    vector<bool> errors;
    errors.resize(FPList.size());
    for (unsigned int i = 0; i < errors.size(); i++)
    {
        errors[i] = false;
    }
    
    for (map<unsigned int, ForbiddenPattern*>::iterator i = FPList.begin(); i != FPList.end(); i++)
    {
        map<unsigned int, ForbiddenPattern*>::iterator j = i;
        j++;
        while (j != FPList.end())
        {
            if ((*i).second->equals((*j).second))
            {
                cout << (*i).first << " is equal to " << (*j).first << endl;
                view->setListMessage((*j).first, wxString::Format(_(" - Repeated (%d)"), (*i).first));
                errors[(*j).first - 1] = true;
            }
            j++;
        }
    }
    
    bool result = true;
    for (unsigned int i = 0; i < errors.size(); i++)
    {
        if (!errors[i])
        {
            view->resetListItem(i + 1);
        }
        else
        {
            result = false;
        }
    }
    return result;
}



ForbiddenPattern* ForbiddenPatternManager::getFP(unsigned int id)
{
    if (FPList.find(id) != FPList.end())
    {
        return FPList[id];
    }
    else
    {
        return NULL;
    }
}

---