Back to index

fet  5.18.0
Public Slots | Public Member Functions | Private Attributes
ModifyConstraintActivitiesNotOverlappingForm Class Reference

#include <modifyconstraintactivitiesnotoverlappingform.h>

Collaboration diagram for ModifyConstraintActivitiesNotOverlappingForm:
Collaboration graph
[legend]

List of all members.

Public Slots

void filterChanged ()
void addActivity ()
void addAllActivities ()
void removeActivity ()
void clear ()
void ok ()
void cancel ()

Public Member Functions

 ModifyConstraintActivitiesNotOverlappingForm (QWidget *parent, ConstraintActivitiesNotOverlapping *ctr)
 ~ModifyConstraintActivitiesNotOverlappingForm ()
bool filterOk (Activity *ac)

Private Attributes

ConstraintActivitiesNotOverlapping_ctr
QList< int > activitiesList
QList< int > notOverlappingActivitiesList

Detailed Description

Definition at line 27 of file modifyconstraintactivitiesnotoverlappingform.h.


Constructor & Destructor Documentation

Definition at line 27 of file modifyconstraintactivitiesnotoverlappingform.cpp.

                                                                                                                                                  : QDialog(parent)
{
       setupUi(this);

       okPushButton->setDefault(true);

       activitiesListWidget->setSelectionMode(QAbstractItemView::SingleSelection);
       notOverlappingActivitiesListWidget->setSelectionMode(QAbstractItemView::SingleSelection);

       connect(cancelPushButton, SIGNAL(clicked()), this, SLOT(cancel()));
       connect(okPushButton, SIGNAL(clicked()), this, SLOT(ok()));
       connect(activitiesListWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(addActivity()));
       connect(addAllActivitiesPushButton, SIGNAL(clicked()), this, SLOT(addAllActivities()));
       connect(notOverlappingActivitiesListWidget, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(removeActivity()));
       connect(teachersComboBox, SIGNAL(activated(QString)), this, SLOT(filterChanged()));
       connect(studentsComboBox, SIGNAL(activated(QString)), this, SLOT(filterChanged()));
       connect(subjectsComboBox, SIGNAL(activated(QString)), this, SLOT(filterChanged()));
       connect(activityTagsComboBox, SIGNAL(activated(QString)), this, SLOT(filterChanged()));
       connect(clearPushButton, SIGNAL(clicked()), this, SLOT(clear()));

       centerWidgetOnScreen(this);
       restoreFETDialogGeometry(this);

       QSize tmp1=teachersComboBox->minimumSizeHint();
       Q_UNUSED(tmp1);
       QSize tmp2=studentsComboBox->minimumSizeHint();
       Q_UNUSED(tmp2);
       QSize tmp3=subjectsComboBox->minimumSizeHint();
       Q_UNUSED(tmp3);
       QSize tmp4=activityTagsComboBox->minimumSizeHint();
       Q_UNUSED(tmp4);
              
       this->_ctr=ctr;
       
       notOverlappingActivitiesList.clear();
       notOverlappingActivitiesListWidget->clear();
       for(int i=0; i<ctr->n_activities; i++){
              int actId=ctr->activitiesId[i];
              this->notOverlappingActivitiesList.append(actId);
              Activity* act=NULL;
              for(int k=0; k<gt.rules.activitiesList.size(); k++){
                     act=gt.rules.activitiesList[k];
                     if(act->id==actId)
                            break;
              }
              assert(act);
              this->notOverlappingActivitiesListWidget->addItem(act->getDescription(gt.rules));
       }
       
       weightLineEdit->setText(CustomFETString::number(ctr->weightPercentage));
       
       teachersComboBox->addItem("");
       for(int i=0; i<gt.rules.teachersList.size(); i++){
              Teacher* tch=gt.rules.teachersList[i];
              teachersComboBox->addItem(tch->name);
       }
       teachersComboBox->setCurrentIndex(0);

       subjectsComboBox->addItem("");
       for(int i=0; i<gt.rules.subjectsList.size(); i++){
              Subject* sb=gt.rules.subjectsList[i];
              subjectsComboBox->addItem(sb->name);
       }
       subjectsComboBox->setCurrentIndex(0);

       activityTagsComboBox->addItem("");
       for(int i=0; i<gt.rules.activityTagsList.size(); i++){
              ActivityTag* st=gt.rules.activityTagsList[i];
              activityTagsComboBox->addItem(st->name);
       }
       activityTagsComboBox->setCurrentIndex(0);

       studentsComboBox->addItem("");
       for(int i=0; i<gt.rules.yearsList.size(); i++){
              StudentsYear* sty=gt.rules.yearsList[i];
              studentsComboBox->addItem(sty->name);
              for(int j=0; j<sty->groupsList.size(); j++){
                     StudentsGroup* stg=sty->groupsList[j];
                     studentsComboBox->addItem(stg->name);
                     for(int k=0; k<stg->subgroupsList.size(); k++){
                            StudentsSubgroup* sts=stg->subgroupsList[k];
                            studentsComboBox->addItem(sts->name);
                     }
              }
       }
       studentsComboBox->setCurrentIndex(0);

       filterChanged();
}

Here is the call graph for this function:

Definition at line 118 of file modifyconstraintactivitiesnotoverlappingform.cpp.

Here is the call graph for this function:


Member Function Documentation

Definition at line 226 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       if(activitiesListWidget->currentRow()<0)
              return;
       int tmp=activitiesListWidget->currentRow();
       int _id=this->activitiesList.at(tmp);
       
       QString actName=activitiesListWidget->currentItem()->text();
       assert(actName!="");
       int i;
       //duplicate?
       for(i=0; i<notOverlappingActivitiesListWidget->count(); i++)
              if(actName==notOverlappingActivitiesListWidget->item(i)->text())
                     break;
       if(i<notOverlappingActivitiesListWidget->count())
              return;
       notOverlappingActivitiesListWidget->addItem(actName);
       notOverlappingActivitiesListWidget->setCurrentRow(notOverlappingActivitiesListWidget->count()-1);
       
       this->notOverlappingActivitiesList.append(_id);
}

Here is the caller graph for this function:

Definition at line 248 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       for(int tmp=0; tmp<activitiesListWidget->count(); tmp++){
              int _id=this->activitiesList.at(tmp);
       
              QString actName=activitiesListWidget->item(tmp)->text();
              assert(actName!="");
              int i;
              //duplicate?
              for(i=0; i<notOverlappingActivitiesList.count(); i++)
                     if(notOverlappingActivitiesList.at(i)==_id)
                            break;
              if(i<notOverlappingActivitiesList.count())
                     continue;
              
              notOverlappingActivitiesListWidget->addItem(actName);
              this->notOverlappingActivitiesList.append(_id);
       }
       
       notOverlappingActivitiesListWidget->setCurrentRow(notOverlappingActivitiesListWidget->count()-1);
}

Here is the caller graph for this function:

Definition at line 221 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       this->close();
}

Here is the caller graph for this function:

Definition at line 287 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       notOverlappingActivitiesListWidget->clear();
       notOverlappingActivitiesList.clear();
}

Here is the caller graph for this function:

Definition at line 123 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       activitiesListWidget->clear();
       this->activitiesList.clear();

       for(int i=0; i<gt.rules.activitiesList.size(); i++){
              Activity* ac=gt.rules.activitiesList[i];
              if(filterOk(ac)){
                     activitiesListWidget->addItem(ac->getDescription(gt.rules));
                     this->activitiesList.append(ac->id);
              }
       }
       
       int q=activitiesListWidget->verticalScrollBar()->minimum();
       activitiesListWidget->verticalScrollBar()->setValue(q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 140 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       QString tn=teachersComboBox->currentText();
       QString stn=studentsComboBox->currentText();
       QString sbn=subjectsComboBox->currentText();
       QString sbtn=activityTagsComboBox->currentText();
       int ok=true;

       //teacher
       if(tn!=""){
              bool ok2=false;
              for(QStringList::Iterator it=act->teachersNames.begin(); it!=act->teachersNames.end(); it++)
                     if(*it == tn){
                            ok2=true;
                            break;
                     }
              if(!ok2)
                     ok=false;
       }

       //subject
       if(sbn!="" && sbn!=act->subjectName)
              ok=false;
              
       //activity tag
       if(sbtn!="" && !act->activityTagsNames.contains(sbtn))
              ok=false;
              
       //students
       if(stn!=""){
              bool ok2=false;
              for(QStringList::Iterator it=act->studentsNames.begin(); it!=act->studentsNames.end(); it++)
                     if(*it == stn){
                            ok2=true;
                            break;
                     }
              if(!ok2)
                     ok=false;
       }
       
       return ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 183 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       double weight;
       QString tmp=weightLineEdit->text();
       weight_sscanf(tmp, "%lf", &weight);
       if(weight<0.0 || weight>100.0){
              QMessageBox::warning(this, tr("FET information"),
                     tr("Invalid weight (percentage)"));
              return;
       }

       if(this->notOverlappingActivitiesList.count()==0){
              QMessageBox::warning(this, tr("FET information"),
                     tr("Empty list of not overlapping activities"));
              return;
       }
       if(this->notOverlappingActivitiesList.count()==1){
              QMessageBox::warning(this, tr("FET information"),
                     tr("Only one selected activity"));
              return;
       }
       
       int i;
       QList<int>::iterator it;
       this->_ctr->activitiesId.clear();
       for(i=0, it=this->notOverlappingActivitiesList.begin(); it!=this->notOverlappingActivitiesList.end(); it++, i++){
              this->_ctr->activitiesId.append(*it);
       }
       this->_ctr->n_activities=i;
              
       this->_ctr->weightPercentage=weight;
       
       gt.rules.internalStructureComputed=false;
       setRulesModifiedAndOtherThings(&gt.rules);
       
       this->close();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 270 of file modifyconstraintactivitiesnotoverlappingform.cpp.

{
       if(notOverlappingActivitiesListWidget->currentRow()<0 || notOverlappingActivitiesListWidget->count()<=0)
              return;
       int tmp=notOverlappingActivitiesListWidget->currentRow();
       
       notOverlappingActivitiesList.removeAt(tmp);

       notOverlappingActivitiesListWidget->setCurrentRow(-1);
       QListWidgetItem* item=notOverlappingActivitiesListWidget->takeItem(tmp);
       delete item;
       if(tmp<notOverlappingActivitiesListWidget->count())
              notOverlappingActivitiesListWidget->setCurrentRow(tmp);
       else
              notOverlappingActivitiesListWidget->setCurrentRow(notOverlappingActivitiesListWidget->count()-1);
}

Here is the caller graph for this function:


Member Data Documentation


The documentation for this class was generated from the following files: