C++ Projet类代码示例

void MainWindow::nouvelleTacheUnitairePreemptable()
{
    QList<QTreeWidgetItem*> selected = projets->selectedItems();
    if (selected.size() != 0 && (selected.at(0)->text(0) == "Projet" || dynamic_cast<TacheComposite*>(tm->trouverTache(selected.at(0)->text(1))))) {
        Tache& tach = tm->ajouterTache("preemptable");
        if (selected.at(0)->text(0) == "Projet") {
            QString id = selected.at(0)->text(1);
            Projet* proj = pm->trouverProjet(id);
            try{proj->ajouterTache(&tach);}catch(ProjetException e){qDebug()<<e.get_info();}
            tach.setProjet_conteneur(proj);
        }
        else {
            TacheComposite* task = dynamic_cast<TacheComposite*>(tm->trouverTache(selected.at(0)->text(1)));
            task->ajouterTache(&tach);
            tach.setTache_conteneur(task);
        }

        try {
            tm->saveToDB();
        } catch (TacheManagerException e) {
            showError("Project Calendar", e.getInfo());
            tm->clearAll();
            pm->clearAll();
            pm->loadProjets();
            tm->loadTaches();
            em->clearAll();
            em->loadEvents();
            displayEvents(this->current_debut,this->current_fin);
        }
        displayProjetsAndTasks();
    }

}

void FenetreGraphique::ajoutMenuProjet(Projet& projet)
{
    //initialisationMenuProjet();
    menuDeroulantProjets->addItem(projet.getId());
    menuDeroulantProjets->setCurrentText(projet.getId());
    //menuDeroulantProjets->setsupprimerPro( Manager<Projet>::getInstance().findObject(projet.getId()));
}

void NouvellePrecedence::remplirComboTache2(QString p){
    ui->comboBoxTache2->clear();
    if(ui->comboBoxProjet2->currentText()!="Projets"){
        Projet* pr =ProjetManager::getInstance().trouverProjet(p);
        for(QMap<QString, Tache*>::const_iterator it=pr->getTaches().cbegin(); it!=pr->getTaches().cend(); it++){
             ui->comboBoxTache2->addItem(it.value()->getId());
        }
    }
}

void AjoutSousTache::remplirComboTacheMere(const QString& p){
    ui->comboBoxTacheMere->clear();
    ui->comboBoxTacheMere->addItem(" ");
    if(p!=" "){
        Projet* projet =ProjetManager::getInstance().trouverProjet(p);
        QMap<QString, Tache*> tachesComposites= projet->getTachesComposites();
        for(QMap<QString, Tache*>::const_iterator it=tachesComposites.begin(); it!=tachesComposites.end(); ++it){
             ui->comboBoxTacheMere->addItem((*it)->getId());
        }
    }
}

void AjoutSousTache::remplirComboSousTache(const QString& p){
    ui->comboBoxSousTache->clear();
    ui->comboBoxSousTache->addItem(" ");
    if(p!=" "){
        Projet* pr =ProjetManager::getInstance().trouverProjet(p);
        for(QMap<QString, Tache*>::const_iterator it=pr->getTaches().begin(); it!=pr->getTaches().end(); ++it){
            if((*it)->getTacheMere()==0)
                ui->comboBoxSousTache->addItem((*it)->getId());
        }
    }
}

void MainWindow::extraire(){
    Projet* p =new Projet("UFR SCiences et Techniques");
    Batiment* b = new Batiment("Bat15", "CIE");

    ui->graphicsView->_etage->setDebutEchelle(new Point("23",0,0));
    ui->graphicsView->_etage->setFinEchelle(new Point("24",0,22));
    ui->graphicsView->_etage->setDistanceEntrePointsDeLEchelle(2.2);
    b->ajouterEtage(ui->graphicsView->_etage);
    p->ajouterBatiment(b);
    EcritureDom ed(p);
}

void SuppressionPrecedence::remplirComboTache(const QString& p){
    ui->comboBoxTache->clear();
    Projet* projet =ProjetManager::getInstance().trouverProjet(p);
    if(projet!=0){
        ui->comboBoxTache->addItem(" ");
        QMap<QString, Tache*> taches= projet->getTaches();
        for(QMap<QString, Tache*>::const_iterator it=taches.begin(); it!=taches.end(); ++it){
             ui->comboBoxTache->addItem((*it)->getId());
             qDebug()<<(*it)->getId();
        }
    }
}

void AjoutPrecedence::EnregistrerPred(){
    //attribut modele à la classe ajoutPrecedence
    QMap<QString, Tache*> pred;
    for(int nb=0; nb<modele.rowCount(); nb++){
        QList<QString>* liste = new QList<QString>;
        testChecked(modele.item(nb), liste);

        for(QList<QString>::const_iterator i = liste->cbegin(); i< liste->cend(); i++){
            Projet* p =ProjetManager::getInstance().trouverProjet(modele.item(nb)->text());
            Tache* t= p->trouverTache(*i);
            pred.insert(t->getId(), t);
        }
    }
    EditeurTache::predecesseurs=pred;
    close();
}

void MyTreeZoneModel::switchEtat(Groupe_selection *zones){

    if(zones == NULL){
        Projet *pro = mainwindow->getCurent_projet();
        zones = pro->getZones();
    }
    Zone * child;
    QVector<Zone*> childs = zones->getZones();

    foreach(child, childs){
        if(child->getType() == Zone::composite){
            switchEtat((Groupe_selection *)child);
        }
        else{
            child->switchEtat();
            emit layoutChanged();
        }
    }
}

bool Tache::canBeSetAtThisDate(Date dateChoisie){
    vector<Programmation*> listeProgPrecedence; size_t j;
    ProgrammationManager& progman = ProgrammationManager::getInstance();
    for(int i=0;i<nbPrecedences;i++){
        if(!precedence[i]->IsPlanifiee()) return false;
        listeProgPrecedence = progman.trouverProgrammation(*this);
        for(j=0;j<listeProgPrecedence.size();j++){
            if (!(listeProgPrecedence[j]->getFin() < dateChoisie)) return false;
        }
    }
    vector <TacheComposee*> listeProgCompo = getTachesParentes();
    for(j=0;j<listeProgCompo.size();j++){
        if (!listeProgCompo[j]->canBeSetAtThisDate(dateChoisie)) return false;
    }
    Projet proj = ProjetManager::getInstance().getProjetAssocie(this);
    if(proj.isDateDisp()){
        if (dateChoisie < proj.getDateDisp()) return false;
    }
    return true;
}

void saveProjetProgrammations(const QString& file, Projet& projet) {
    QFile newfile(file);
    if (!newfile.open(QIODevice::WriteOnly | QIODevice::Text))
        throw ToolsException("XmlParser erreur : impossible d'ouvrir le fichier !");
    QXmlStreamWriter stream(&newfile);
    stream.setAutoFormatting(true);
    stream.writeStartDocument();
    projet.exportProgrammations(stream);
    stream.writeEndDocument();
    newfile.close();
}

Groupe_selection * MyTreeZoneModel::addGroup(QModelIndex item){

    Groupe_selection *main_composite;
    Projet *pro = mainwindow->getCurent_projet();

    if(item.isValid() == false)
        main_composite = pro->getZones();
    else
        main_composite = nodeFromIndex(item);

    if(main_composite->getType() != Zone::composite)
        main_composite = main_composite->getParent();

    Groupe_selection *group = new Groupe_selection(main_composite);
    emit beginResetModel();
    main_composite->appendChild(group);
    emit endResetModel();

    return group;
}

void FenetreUnitaire::load()
{

    ProjetManager& pm= ProjetManager::getInstance();
    Projet* projet = pm.trouverProjet(idProjet->currentText());
    dureeUnitaire->clear();
    preemptive->setChecked(false);
    idComposite->clear();
    idUnitaire->clear();
    titreUnitaire->clear();
    echeanceUnitaire->setDateTime(QDateTime::currentDateTime());
    dispoUnitaire->setDateTime(QDateTime::currentDateTime());

    if(projet)
    {
        preemptive->setEnabled(true);
        idUnitaire->setEnabled(true);
        dispoUnitaire->setEnabled(true);
        echeanceUnitaire->setEnabled(true);
        titreUnitaire->setEnabled(true);
        dureeUnitaire->setEnabled(true);
        idComposite->setEnabled(true);
        idComposite->clear();
        idComposite->addItem("");
        dispoProjet->setDateTime(projet->getDispo());
        echeanceProjet->setDateTime(projet->getEcheance());
        for(Projet::taches_iterator it = projet->begin_taches() ; it != projet->end_taches() ; ++it){
            if(typeid(**it) == typeid(TacheComposite)){
                idComposite->addItem((*it)->getId());
            }
        }
    }else{
        dureeUnitaire->setDisabled(true);
        dispoUnitaire->setDisabled(true);
        idComposite->setDisabled(true);
        idUnitaire->setDisabled(true);
        echeanceUnitaire->setDisabled(true);
        titreUnitaire->setDisabled(true);
        preemptive->setDisabled(true);
    }
}

Tache *ProjetManager::ajouterTache(const QString & id_projet, const QString & id, const QString & titre, const QDate & dispo, const QDate & deadline, const Duree & dur, const bool & pre)
{
   if (this->trouverTache(id)) {
      throw CalendarException("Erreur AjouterTache : l'id de la tache existe déjà");
   }
   Projet * p = this->trouverProjet(id_projet);
   if ( p == 0 ) {
      throw CalendarException("Erreur AjouterTache : l'id_projet n'existe pas");
   }

   Tache * t = 0;
   if(dur.getDureeEnMinutes() != 0 ) { // si une durée est fixée, la tâche est unitaire
      if (pre) {
         t = new TachePreemptable(id,titre,dispo,deadline,dur);
      } else {
         t= new TacheNonPreemptable(id, titre, dispo, deadline, dur);
      }
   } else {
      t = new TacheComposite(id,titre,dispo,deadline);
   }
   p->ajouterTache(*t);
   return t;
}

void MainWindow::onTreeWidgetItemDoubleClicked(QTreeWidgetItem * item, int column)
{
    if (column==1) { // nom
        QString id = item->text(1);
        edittitle* edittitre =  new edittitle(this);
        edittitre->setTitle(id);
        if (edittitre->exec() == QDialog::Accepted) {
            QString newTitre = edittitre->getTitle();
            if(item->text(0)=="Projet"){
                Projet* tmp = pm->trouverProjet(id);
                tmp->setNom(newTitre);
            }
            else{
                Tache* tmp = tm->trouverTache(id);
                tmp->setTitre(newTitre);
            }

        }
        delete edittitre;

    }
    if (column==2) { // date dispo
        QString id = item->text(1);
        popupdispo = new datedispo(this);
        popupdispo->setDate(QDate::fromString(item->text(2),Qt::TextDate));
        if (popupdispo->exec() == QDialog::Accepted) {
            QDate dateDisponible = popupdispo->getDate();
            if(item->text(0)=="Projet"){
                Projet* tmp = pm->trouverProjet(id);
                tmp->setDispo(dateDisponible);
            }
            else{
                Tache* tmp = tm->trouverTache(id);
                tmp->setDateDisponibilite(dateDisponible);
            }
        }
        delete popupdispo;

    }
    if (column==3 && item->text(0) != "Projet" && item->text(0) != "Tâche Composite") { //durée
        QString id = item->text(1);
        editduree* duree =  new editduree(this);
        if (duree->exec() == QDialog::Accepted) {
            TIME::Duree dur = duree->getDuree();
            TacheUnitaire* tmp = dynamic_cast<TacheUnitaire*>(tm->trouverTache(id));
            try{tmp->setDuree(dur);}catch(TacheException e){
               showError("Project Calendar", "\n Une tache unitaire non preemptable ne peut durer plus de 12h");
            }
        }
        delete duree;

    }
    if (column==4 && item->text(0) != "Projet") { // echeance
        QString id = item->text(1);
        editecheance* echeance =  new editecheance(this);
        echeance->setDate(QDate::fromString(item->text(4),Qt::TextDate));
        if (echeance->exec() == QDialog::Accepted) {
            QDate dateEcheance = echeance->getDate();
            Tache* tmp = tm->trouverTache(id);
            tmp->setEcheance(dateEcheance);
        }
        delete echeance;

    }
    if (column==5 && (item->text(0) == "Tâche unitaire" || item->text(0) == "Tâche unitaire préemptable") && item->text(0) != "Tâche Composite") { // etat
        QString id = item->text(1);
        editetat* etat =  new editetat(this);
        TacheUnitaire* tmp = dynamic_cast<TacheUnitaire*>(tm->trouverTache(id));
        etat->setTache(tmp);
        if (etat->exec() == QDialog::Accepted) {
            // do nothing
        }
        delete etat;
    }
    try {
        tm->saveToDB();
        pm->saveToDB();
    }catch (ProjetManagerException e) {
        showError("Project Calendar", e.getInfo()+"\nLes noms de projets doivent être uniques.");
        tm->clearAll();
        pm->clearAll();
        pm->loadProjets();
        tm->loadTaches();
        em->clearAll();
        em->loadEvents();
        displayEvents(this->current_debut,this->current_fin);
    }
    catch (TacheManagerException e) {
        showError("Project Calendar", e.getInfo()+"\nDeux tâches contenues dans la même tache ou le même projet ne peuvent avoir le même nom.");
        tm->clearAll();
        pm->clearAll();
        pm->loadProjets();
        tm->loadTaches();
        em->clearAll();
        em->loadEvents();
        displayEvents(this->current_debut,this->current_fin);
    }

    displayProjetsAndTasks();
}