diff --git a/sources/diagram.cpp b/sources/diagram.cpp index dbf70e658..568efa656 100644 --- a/sources/diagram.cpp +++ b/sources/diagram.cpp @@ -36,6 +36,7 @@ #include "diagrameventinterface.h" #include "qetapp.h" #include "elementcollectionhandler.h" +#include "element.h" const int Diagram::xGrid = 10; const int Diagram::yGrid = 10; @@ -57,7 +58,8 @@ Diagram::Diagram(QETProject *project) : use_border_ (true), draw_terminals_ (true), draw_colored_conductors_ (true), - m_event_interface (nullptr) + m_event_interface (nullptr), + m_freeze_new_elements_ (false) { setProject(project); qgi_manager_ = new QGIManager(this); @@ -467,6 +469,9 @@ QDomDocument Diagram::toXml(bool whole_content) { if (!m_conductors_autonum_name.isEmpty()) { racine.setAttribute("conductorAutonum", m_conductors_autonum_name); } + + //Default New Element + racine.setAttribute("freezeNewElement", m_freeze_new_elements_ ? "true" : "false"); } else { //this method with whole_content to false, @@ -649,6 +654,9 @@ bool Diagram::fromXml(QDomElement &document, QPointF position, bool consider_inf // Load the autonum m_conductors_autonum_name = root.attribute("conductorAutonum"); + + // Load Freeze New Element + m_freeze_new_elements_ = root.attribute("freezeNewElement").toInt(); } // if child haven't got a child, loading is finish (diagram is empty) @@ -1156,6 +1164,50 @@ bool Diagram::usesTitleBlockTemplate(const QString &name) { return(name == border_and_titleblock.titleBlockTemplateName()); } +/** + * @brief Diagram::freezeElements + * Freeze every existent element label. + */ +void Diagram::freezeElements() { + foreach (Element *elmt, elements()) { + elmt->freezeLabel(); + } +} + +/** + * @brief Diagram::unfreezeElements + * Unfreeze every existent element label. + */ +void Diagram::unfreezeElements() { + foreach (Element *elmt, elements()) { + elmt->unfreezeLabel(); + } +} + +/** + * @brief Diagram::freezeNew + * Set new element label to be frozen. + */ +void Diagram::freezeNew() { + m_freeze_new_elements_ = true; +} + +/** + * @brief Diagram::unfreezeNew + * Set new element label to not be frozen. + */ +void Diagram::unfreezeNew() { + m_freeze_new_elements_ = false; +} + +/** + * @brief Diagram::freezeNewElements + * @return current freeze new element status . + */ +bool Diagram::freezeNewElements() { + return m_freeze_new_elements_; +} + /** * @brief Diagram::adjustSceneRect * Recalcul and adjust the size of the scene diff --git a/sources/diagram.h b/sources/diagram.h index 4b838000d..e48535fc4 100644 --- a/sources/diagram.h +++ b/sources/diagram.h @@ -102,6 +102,8 @@ class Diagram : public QGraphicsScene QString m_conductors_autonum_name; DiagramEventInterface *m_event_interface; + + bool m_freeze_new_elements_; // METHODS protected: @@ -200,6 +202,12 @@ class Diagram : public QGraphicsScene QUndoStack &undoStack(); QGIManager &qgiManager(); + void freezeElements(); + void unfreezeElements(); + void freezeNew(); + void unfreezeNew(); + bool freezeNewElements(); + public slots: void adjustSceneRect (); void titleChanged(const QString &); diff --git a/sources/diagramevent/diagrameventaddelement.cpp b/sources/diagramevent/diagrameventaddelement.cpp index ddfd794a4..a3a65e300 100644 --- a/sources/diagramevent/diagrameventaddelement.cpp +++ b/sources/diagramevent/diagrameventaddelement.cpp @@ -234,5 +234,6 @@ void DiagramEventAddElement::addElement() }; m_diagram -> undoStack().push(undo_object); element->setSeq(); + element->freezeNewAddedElement(); element->updateLabel(); } diff --git a/sources/projectconfigpages.cpp b/sources/projectconfigpages.cpp index 507e3e837..14cfbd806 100644 --- a/sources/projectconfigpages.cpp +++ b/sources/projectconfigpages.cpp @@ -29,6 +29,9 @@ #include "numerotationcontext.h" #include "folioautonumbering.h" #include "elementautonumberingw.h" +#include "autonumberingmanagementw.h" +#include "ui_autonumberingmanagementw.h" + /** Constructor @param project Project this page is editing. @@ -255,6 +258,9 @@ void ProjectAutoNumConfigPage::initWidgets() { tab_widget = new QTabWidget(this); + management_tab_widget = new QWidget(this); + m_amw = new AutoNumberingManagementW(project(), management_tab_widget); + //Conductor Tab conductor_tab_widget = new QWidget(this); conductor_tab_widget->setObjectName("ConductorTab"); @@ -314,6 +320,9 @@ void ProjectAutoNumConfigPage::initWidgets() { */ void ProjectAutoNumConfigPage::initLayout() { + //Management Tab + tab_widget->addTab(management_tab_widget, tr("Management")); + //Conductor Tab tab_widget->addTab(conductor_tab_widget, tr("Conductor")); @@ -365,7 +374,7 @@ void ProjectAutoNumConfigPage::initLayout() { //Auto Numbering Tab tab_widget->addTab(autoNumbering_tab_widget,tr ("Folio Auto Numbering")); - tab_widget->resize(465,590); + tab_widget->resize(540,590); } /** @@ -410,20 +419,26 @@ void ProjectAutoNumConfigPage::buildConnections() { connect(tab_widget,SIGNAL(currentChanged(int)),this,SLOT(tabChanged(int))); + //Management Tab + connect (m_amw, SIGNAL(applyPressed()), this, SLOT(applyManagement())); + //Conductor Tab - connect (m_context_cb_conductor, SIGNAL (currentTextChanged(QString)), m_saw_conductor, SLOT(applyEnableOnContextChanged(QString))); + connect (m_context_cb_conductor, SIGNAL (currentTextChanged(QString)), m_saw_conductor, SLOT (applyEnableOnContextChanged(QString))); + connect (m_context_cb_conductor, SIGNAL (currentTextChanged(QString)), this, SLOT (updateContext_conductor(QString))); connect (m_context_cb_conductor, SIGNAL (currentIndexChanged(QString)), this, SLOT (updateContext_conductor(QString))); connect (m_saw_conductor, SIGNAL (applyPressed()), this, SLOT (saveContext_conductor())); connect (m_remove_pb_conductor, SIGNAL (clicked()), this, SLOT (removeContext_conductor())); //Element Tab connect (m_context_cb_element, SIGNAL (currentTextChanged(QString)), m_saw_element, SLOT(applyEnableOnContextChanged(QString))); + connect (m_context_cb_element, SIGNAL (currentTextChanged(QString)), this, SLOT (updateContext_element(QString))); connect (m_context_cb_element, SIGNAL (currentIndexChanged(QString)), this, SLOT (updateContext_element(QString))); connect (m_saw_element, SIGNAL (applyPressed()), this, SLOT (saveContext_element())); connect (m_remove_pb_element, SIGNAL (clicked()), this, SLOT (removeContext_element())); //Folio Tab connect (m_context_cb_folio, SIGNAL (currentTextChanged(QString)), m_saw_folio, SLOT(applyEnableOnContextChanged(QString))); + connect (m_context_cb_folio, SIGNAL (currentTextChanged(QString)), this, SLOT (updateContext_folio(QString))); connect (m_context_cb_folio, SIGNAL (currentIndexChanged(QString)), this, SLOT (updateContext_folio(QString))); connect (m_saw_folio, SIGNAL (applyPressed()), this, SLOT (saveContext_folio())); connect (m_remove_pb_folio, SIGNAL (clicked()), this, SLOT (removeContext_folio())); @@ -562,6 +577,84 @@ void ProjectAutoNumConfigPage::applyAutoNum() { } } +/** + * @brief ProjectAutoNumConfigPage::applyAutoManagement + * Apply Management Options in Selected Folios + */ +void ProjectAutoNumConfigPage::applyManagement() { + int from; + int to; + //Apply to Entire Project + if (m_amw->ui->m_apply_project_rb->isChecked()) { + from = 0; + to = project()->diagrams().size() - 1; + } + //Apply to selected Folios + else { + from = m_amw->ui->m_from_folios_cb->itemData(m_amw->ui->m_from_folios_cb->currentIndex()).toInt(); + to = m_amw->ui->m_to_folios_cb->itemData(m_amw->ui->m_to_folios_cb->currentIndex()).toInt(); + } + + //Conductor Autonumbering Status + if (m_amw->ui->m_both_conductor_rb->isChecked()) { + + } + else if (m_amw->ui->m_new_conductor_rb->isChecked()) { + + } + else if (m_amw->ui->m_existent_conductor_rb->isChecked()) { + + } + else if (m_amw->ui->m_disable_conductor_rb->isChecked()) { + + } + + //Element Autonumbering Update Policy + //Allow Both Existent and New Elements + if (m_amw->ui->m_both_element_rb->isChecked()) { + //Unfreeze Existent and New Elements + project()->unfreezeExistentElementLabel(from,to); + project()->unfreezeNewElementLabel(from,to); + project()->setFreezeNewElements(false); + } + //Allow Only New + else if (m_amw->ui->m_new_element_rb->isChecked()) { + //Freeze Existent and Unfreeze New Elements + project()->freezeExistentElementLabel(from,to); + project()->unfreezeNewElementLabel(from,to); + project()->setFreezeNewElements(false); + } + //Allow Only Existent + else if (m_amw->ui->m_existent_element_rb->isChecked()) { + //Freeze New and Unfreeze Existent Elements, Set Freeze Element Project Wide + project()->unfreezeExistentElementLabel(from,to); + project()->freezeNewElementLabel(from,to); + project()->setFreezeNewElements(true); + } + //Disable + else if (m_amw->ui->m_disable_element_rb->isChecked()) { + //Freeze Existent and New Elements, Set Freeze Element Project Wide + project()->freezeExistentElementLabel(from,to); + project()->freezeNewElementLabel(from,to); + project()->setFreezeNewElements(true); + } + + //Folio Autonumbering Status + if (m_amw->ui->m_both_folio_rb->isChecked()) { + + } + else if (m_amw->ui->m_new_folio_rb->isChecked()) { + + } + else if (m_amw->ui->m_existent_folio_rb->isChecked()) { + + } + else if (m_amw->ui->m_disable_folio_rb->isChecked()) { + + } + +} + /** * @brief ProjectAutoNumConfigPage::removeContext * Remove from project the current conductor numerotation context @@ -613,12 +706,15 @@ void ProjectAutoNumConfigPage::changeToTab(int i){ * Used to resize window to correct size */ void ProjectAutoNumConfigPage::tabChanged(int i){ - if (i>0){ - if (tab_widget->currentIndex()==3){ - tab_widget->resize(470,tab_widget->height()); + if (i>=1){ + if (tab_widget->currentIndex() == 4){ + tab_widget->resize(480,tab_widget->height()); } else { - tab_widget->resize(465,tab_widget->height()); + tab_widget->resize(475,tab_widget->height()); } } + else { + tab_widget->resize(540,tab_widget->height()); + } } diff --git a/sources/projectconfigpages.h b/sources/projectconfigpages.h index bfcc58a15..501dcfe41 100644 --- a/sources/projectconfigpages.h +++ b/sources/projectconfigpages.h @@ -36,6 +36,7 @@ class QComboBox; class QPushButton; class FolioAutonumberingW; class ElementAutonumberingW; +class AutoNumberingManagementW; /** This class, derived from ConfigPage, aims at providing the basic skeleton @@ -152,6 +153,7 @@ class ProjectAutoNumConfigPage : public ProjectConfigPage { void removeContext_element(); void applyAutoNum(); + void applyManagement(); void tabChanged(int); @@ -164,6 +166,7 @@ class ProjectAutoNumConfigPage : public ProjectConfigPage { //Attributes private: QTabWidget *tab_widget; + QWidget *management_tab_widget; QWidget *conductor_tab_widget; QWidget *element_tab_widget; QWidget *folio_tab_widget; @@ -182,7 +185,7 @@ class ProjectAutoNumConfigPage : public ProjectConfigPage { SelectAutonumW *m_saw_folio; SelectAutonumW *m_saw_element; FolioAutonumberingW *m_faw; - ElementAutonumberingW *m_eaw; + AutoNumberingManagementW *m_amw; }; diff --git a/sources/qetgraphicsitem/element.cpp b/sources/qetgraphicsitem/element.cpp index 28e70f305..c0031f039 100644 --- a/sources/qetgraphicsitem/element.cpp +++ b/sources/qetgraphicsitem/element.cpp @@ -27,6 +27,7 @@ #include "PropertiesEditor/propertieseditordialog.h" #include "elementpropertieswidget.h" #include "numerotationcontextcommands.h" +#include "diagramcontext.h" /** Constructeur pour un element sans scene ni parent @@ -819,3 +820,46 @@ QString Element::getPrefix() { void Element::setPrefix(QString prefix) { m_prefix = prefix; } + +/** + * @brief Element::freezeLabel + * Freeze this element label + */ +void Element::freezeLabel() { + DiagramContext &dc = this->rElementInformations(); + QString freezelabel = dc["label"].toString(); + QString label = assignVariables(freezelabel,this); + if (!(label == freezelabel)) { + dc.addValue("frozenlabel", freezelabel); + dc.addValue("label",label); + this->setTaggedText("label", label); + this->setElementInformations(dc); + } +} + +/** + * @brief Element::unfreezeLabel + * Unfreeze this element label + */ +void Element::unfreezeLabel() { + DiagramContext &dc = this->rElementInformations(); + QString label = dc["label"].toString(); + QString frozenlabel = dc["frozenlabel"].toString(); + if (frozenlabel == "") return; + dc.addValue("frozenlabel", ""); + dc.addValue("label",frozenlabel); + frozenlabel = assignVariables(frozenlabel,this); + this->setTaggedText("label", frozenlabel); + this->setElementInformations(dc); +} + +/** + * @brief Element::freezeNewAddedElement + * Freeze this label if needed + */ +void Element::freezeNewAddedElement() { + if (this->diagram()->freezeNewElements() || this->diagram()->project()->freezeNewElements()) { + freezeLabel(); + } + else return; +} diff --git a/sources/qetgraphicsitem/element.h b/sources/qetgraphicsitem/element.h index 07a1ca95a..ac24a6410 100644 --- a/sources/qetgraphicsitem/element.h +++ b/sources/qetgraphicsitem/element.h @@ -138,6 +138,9 @@ class Element : public QetGraphicsItem { void setSeq (); void setPrefix(QString); QString getPrefix(); + void freezeLabel(); + void unfreezeLabel(); + void freezeNewAddedElement(); //ATTRIBUTES protected: diff --git a/sources/qetproject.cpp b/sources/qetproject.cpp index 418ef5461..8ca00afa3 100644 --- a/sources/qetproject.cpp +++ b/sources/qetproject.cpp @@ -49,7 +49,7 @@ QETProject::QETProject(int diagrams, QObject *parent) : folioSheetsQuantity (0 ), m_auto_conductor (true ), m_elements_collection (nullptr), - m_auto_folio (true ) + m_freeze_new_elements (false) { // 0 a n schema(s) vide(s) int diagrams_count = qMax(0, diagrams); @@ -79,8 +79,7 @@ QETProject::QETProject(const QString &path, QObject *parent) : titleblocks_ (this ), folioSheetsQuantity (0 ), m_auto_conductor (true ), - m_elements_collection (nullptr), - m_auto_folio (true ) + m_elements_collection (nullptr) { //Open the file QFile project_file(path); @@ -418,10 +417,10 @@ QHash QETProject::elementAutoNum() const { } /** - * @brief QETProject::elementAutoNum_2 + * @brief QETProject::elementAutoNumHash * @return Title and Formula Hash */ -QHash QETProject::elementAutoNum_2() { +QHash QETProject::elementAutoNumHash() { return m_element_autonum_formula; } @@ -573,6 +572,70 @@ NumerotationContext QETProject::folioAutoNum (const QString &key) const { else return NumerotationContext(); } +/** + * @brief QETProject::freezeExistentElementLabel + * Freeze Existent Elements in the selected folios + * @param from - first folio index to apply freeze + * @param to - last folio index to apply freeze + */ +void QETProject::freezeExistentElementLabel(int from, int to) { + for (int i = from; i <= to; i++) { + diagrams_.at(i)->freezeElements(); + } +} + +/** + * @brief QETProject::unfreezeExistentElementLabel + * Unfreeze Existent Elements in the selected folios + * @param from - first folio index to apply unfreeze + * @param to - last folio index to apply unfreeze + */ +void QETProject::unfreezeExistentElementLabel(int from, int to) { + for (int i = from; i <= to; i++) { + diagrams_.at(i)->unfreezeElements(); + } +} + +/** + * @brief QETProject::freezeNewElementLabel + * Freeze New Elements in the selected folios + * @param from - first folio index to apply freeze + * @param to - last folio index to apply freeze + */ +void QETProject::freezeNewElementLabel(int from, int to) { + for (int i = from; i <= to; i++) { + diagrams_.at(i)->freezeNew(); + } +} + +/** + * @brief QETProject::unfreezeNewElementLabel + * Unfreeze New Elements in the selected folios + * @param from - first folio index to apply unfreeze + * @param to - last folio index to apply unfreeze + */ +void QETProject::unfreezeNewElementLabel(int from, int to) { + for (int i = from; i <= to; i++) { + diagrams_.at(i)->unfreezeNew(); + } +} + +/** + * @brief QETProject::freezeNewElements + * @return freeze new elements Project Wide status + */ +bool QETProject::freezeNewElements() { + return m_freeze_new_elements; +} + +/** + * @brief QETProject::setfreezeNewElements + * Set Project Wide freeze new elements + */ +void QETProject::setFreezeNewElements(bool set) { + m_freeze_new_elements = set; +} + /** * @brief QETProject::autoConductor * @return true if use of auto conductor is authorized. @@ -583,16 +646,6 @@ bool QETProject::autoConductor() const return m_auto_conductor; } -/** - * @brief QETProject::autoFolio - * @return true if use of auto folio is authorized. - * See also Q_PROPERTY autoConductor - */ -bool QETProject::autoFolio() const -{ - return m_auto_folio; -} - /** * @brief QETProject::setAutoConductor * @param ac @@ -605,18 +658,6 @@ void QETProject::setAutoConductor(bool ac) m_auto_conductor = ac; } -/** - * @brief QETProject::setAutoFolio - * @param ac - * Enable the use of auto folio if true - * See also Q_PROPERTY autoFolio - */ -void QETProject::setAutoFolio(bool af) -{ - if (af != m_auto_folio) - m_auto_folio = af; -} - /** * @brief QETProject::autoFolioNumberingNewFolios * emit Signal to add new Diagram with autonum @@ -1332,6 +1373,7 @@ void QETProject::readDefaultPropertiesXml(QDomDocument &xml_project) { m_current_element_autonum = element_autonums.attribute("current_autonum"); m_current_element_formula = element_autonums.attribute("current_formula"); + m_freeze_new_elements = element_autonums.attribute("freeze_new_elements").toInt(); foreach (QDomElement elmt, QET::findInDomElement(element_autonums, "element_autonum")) { NumerotationContext nc; @@ -1414,6 +1456,7 @@ void QETProject::writeDefaultPropertiesXml(QDomElement &xml_element) { QDomElement element_autonums = xml_document.createElement("element_autonums"); element_autonums.setAttribute("current_autonum", m_current_element_autonum); element_autonums.setAttribute("current_formula", m_current_element_formula); + element_autonums.setAttribute("freeze_new_elements", m_freeze_new_elements ? "true" : "false"); foreach (QString key, elementAutoNum().keys()) { QDomElement element_autonum = elementAutoNum(key).toXml(xml_document, "element_autonum"); if (key != "" && elementAutoNumFormula(key) != "") { diff --git a/sources/qetproject.h b/sources/qetproject.h index c84e05536..23575b321 100644 --- a/sources/qetproject.h +++ b/sources/qetproject.h @@ -108,7 +108,7 @@ class QETProject : public QObject QHash conductorAutoNum() const; QHash elementAutoNum() const; - QHash elementAutoNum_2(); + QHash elementAutoNumHash(); QHash folioAutoNum() const; void addConductorAutoNum (QString key, NumerotationContext context); void addElementAutoNum (QString key, NumerotationContext context); @@ -125,12 +125,18 @@ class QETProject : public QObject QString elementAutoNumFormula() const; QString elementCurrentAutoNum () const; + void freezeExistentElementLabel(int,int); + void freezeNewElementLabel(int,int); + void unfreezeExistentElementLabel(int,int); + void unfreezeNewElementLabel(int,int); + bool freezeNewElements(); + void setFreezeNewElements(bool); + bool autoConductor () const; bool autoElement () const; bool autoFolio () const; void setAutoConductor (bool ac); void setAutoElement (bool ae); - void setAutoFolio (bool af); void autoFolioNumberingNewFolios (); void autoFolioNumberingSelectedFolios(int, int, QString); @@ -250,7 +256,7 @@ class QETProject : public QObject int folioSheetsQuantity; bool m_auto_conductor; XmlElementCollection *m_elements_collection; - bool m_auto_folio; + bool m_freeze_new_elements; }; Q_DECLARE_METATYPE(QETProject *) #endif diff --git a/sources/ui/autonumberingdockwidget.cpp b/sources/ui/autonumberingdockwidget.cpp index 6096ef9ed..b4ddb7632 100644 --- a/sources/ui/autonumberingdockwidget.cpp +++ b/sources/ui/autonumberingdockwidget.cpp @@ -153,7 +153,7 @@ void AutoNumberingDockWidget::setActive() { //Element QString current_element_autonum = project_->elementCurrentAutoNum(); QString element_formula = project_->elementAutoNumFormula(); - QString active_element_autonum = project_->elementAutoNum_2().key(element_formula); + QString active_element_autonum = project_->elementAutoNumHash().key(element_formula); int el_index = ui->m_element_cb->findText(active_element_autonum); ui->m_element_cb->setCurrentIndex(el_index); diff --git a/sources/ui/autonumberingmanagementw.cpp b/sources/ui/autonumberingmanagementw.cpp new file mode 100644 index 000000000..a7aed1ba0 --- /dev/null +++ b/sources/ui/autonumberingmanagementw.cpp @@ -0,0 +1,214 @@ +/* + Copyright 2006-2016 The QElectroTech Team + This file is part of QElectroTech. + + QElectroTech 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. + + QElectroTech 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 QElectroTech. If not, see . +*/ +#include "autonumberingmanagementw.h" +#include "ui_autonumberingmanagementw.h" +#include "numparteditorw.h" +#include +#include "numerotationcontextcommands.h" +#include "elementautonumberingw.h" +#include "ui_elementautonumberingw.h" +#include "qdebug.h" +#include "qetproject.h" +#include "diagram.h" + +/** + * Constructor + */ +AutoNumberingManagementW::AutoNumberingManagementW(QETProject *project, QWidget *parent) : + QWidget(parent), + project_(project) +{ + ui = new Ui::AutoNumberingManagementW; + ui->setupUi(this); + ui->m_apply_locations_rb->setHidden(true); + ui->m_selected_locations_le->setHidden(true); + ui->conductorWidget->setHidden(true); + ui->folioWidget->setHidden(true); + ui->m_selected_folios_widget->setDisabled(true); + ui->m_selected_folios_le->setDisabled(true); + ui->m_selected_folios_le->setReadOnly(true); + applyEnable(false); + setProjectContext(); +} + +/** + * Destructor + */ +AutoNumberingManagementW::~AutoNumberingManagementW() +{ + delete ui; +} + +/** + * @brief AutoNumberingManagementW::setProjectContext + * Add Default Project Status + */ +void AutoNumberingManagementW::setProjectContext() { + ui->m_status_cb->addItem(tr("Under Development")); + ui->m_status_cb->addItem(tr("Installing")); + ui->m_status_cb->addItem(tr("Built")); +} + +/** + * @brief AutoNumberingManagementW::on_m_status_cb_currentIndexChanged + * Load Default Status Options + */ +void AutoNumberingManagementW::on_m_status_cb_currentIndexChanged(int index) { + + //Under Development + if (index == 0) { + ui->conductorWidget->setEnabled(true); + ui->elementWidget->setEnabled(true); + ui->folioWidget->setEnabled(true); + ui->m_both_conductor_rb->setChecked(true); + ui->m_both_element_rb->setChecked(true); + ui->m_both_folio_rb->setChecked(true); + } + //Installing + else if (index == 1) { + ui->conductorWidget->setEnabled(true); + ui->elementWidget->setEnabled(true); + ui->folioWidget->setEnabled(true); + ui->m_new_conductor_rb->setChecked(true); + ui->m_new_element_rb->setChecked(true); + ui->m_new_folio_rb->setChecked(true); + } + //Built + else if (index == 2) { + ui->m_disable_conductor_rb->setChecked(true); + ui->m_disable_element_rb->setChecked(true); + ui->m_disable_folio_rb->setChecked(true); + } +} + +/** + * @brief AutoNumberingManagementW::on_m_apply_folios_rb_clicked + * Set From Folios Combobox + */ +void AutoNumberingManagementW::on_m_apply_folios_rb_clicked() { + if (ui->m_apply_folios_rb->isChecked()) { + ui->m_selected_folios_widget->setEnabled(true); + ui->m_selected_folios_le->setEnabled(true); + if (ui->m_from_folios_cb->count()<=0) { + ui->m_from_folios_cb->clear(); + ui->m_from_folios_cb->addItem(""); + foreach (Diagram *diagram, project_->diagrams()){ + if (diagram->title() != "") + ui->m_from_folios_cb->addItem(diagram->title(),diagram->folioIndex()); + else ui->m_from_folios_cb->addItem(QString::number(diagram->folioIndex()),diagram->folioIndex()); + } + } + if (ui->m_from_folios_cb->currentIndex() > 0) + applyEnable(true); + else applyEnable(false); + } +} + +/** + * @brief AutoNumberingManagementW::on_m_from_folios_cb_currentIndexChanged + * Set To Folios Combobox + */ +void AutoNumberingManagementW::on_m_from_folios_cb_currentIndexChanged(int index) { + ui->m_to_folios_cb->clear(); + ui->m_selected_folios_le->clear(); + ui->m_selected_folios_le->setEnabled(true); + if (index > 0) { + ui->m_to_folios_cb->setEnabled(true); + ui->m_to_folios_cb->addItem(""); + for (int i=index;idiagrams().size();i++) { + if (project_->diagrams().at(i)->title() != "") { + ui->m_to_folios_cb->addItem(project_->diagrams().at(i)->title(),project_->diagrams().at(i)->folioIndex()); + } + else ui->m_to_folios_cb->addItem(QString::number(project_->diagrams().at(i)->folioIndex()),project_->diagrams().at(i)->folioIndex()); + } + applyEnable(true); + ui->m_selected_folios_le->clear(); + ui->m_selected_folios_le->insert(ui->m_from_folios_cb->currentText()); + } + else applyEnable(false); +} + +/** + * @brief AutoNumberingManagementW::on_m_to_folios_cb_currentIndexChanged + * Set selected folios Line Edit content + */ +void AutoNumberingManagementW::on_m_to_folios_cb_currentIndexChanged(int index) { + if (index > 0) { + QString from = ui->m_from_folios_cb->currentText(); + QString to = ui->m_to_folios_cb->currentText(); + ui->m_selected_folios_le->clear(); + ui->m_selected_folios_le->insert(from + " - " + to); + ui->m_selected_folios_le->setDisabled(true); + } + applyEnable(true); +} + +/** + * @brief AutoNumberingManagementW::on_m_apply_project_rb_clicked + * Disable folio widget + */ +void AutoNumberingManagementW::on_m_apply_project_rb_clicked() { + ui->m_selected_folios_widget->setDisabled(true); + ui->m_selected_folios_le->setDisabled(true); + applyEnable(true); +} + +/** + * @brief AutoNumberingManagementW::on_buttonBox_clicked + * Action on @buttonBox clicked + */ +void AutoNumberingManagementW::on_buttonBox_clicked(QAbstractButton *button) { + //transform button to int + int answer = ui -> buttonBox -> buttonRole(button); + switch (answer) { + //apply the context in the diagram displayed by @diagram_chooser. + case QDialogButtonBox::ApplyRole: + applyEnable(false); + emit applyPressed(); + break; + case QDialogButtonBox::HelpRole: + QMessageBox::information(this, tr("Auto Numbering Management", "title window"), + tr("In this Menu you can set whether you want the Auto Numberings to be updated or not." + " For Element Auto Numbering you have 4 options of Update Policy:\n" + "-Both: both New and Existent Element labels will be updated. This is the default option.\n" + "-Update Only New: only new created Elements will be updated. Existent Element labels will be frozen.\n" + "-Update Only Existent: only existent Elements will be updated. New Elements will be assigned " + "their formula but will not update once created.\n" + "-Disable: both New and Existent Element labels will not be updated. This is valid for new folios as well.\n" + "Note: These options DO NOT allow or block Auto Numberings, only their Update Policy." + )); + break; + } +} + +/** + * @brief AutoNumberingManagementW::applyEnable + * enable/disable the apply button + */ +void AutoNumberingManagementW::applyEnable(bool b) { + if (b){ + bool valid= true; + if (ui->m_apply_project_rb->isChecked()) + ui -> buttonBox -> button(QDialogButtonBox::Apply) -> setEnabled(valid); + else if (ui->m_apply_folios_rb->isChecked()) + ui -> buttonBox -> button(QDialogButtonBox::Apply) -> setEnabled(valid); + } + else { + ui -> buttonBox -> button(QDialogButtonBox::Apply) -> setEnabled(b); + } +} diff --git a/sources/ui/autonumberingmanagementw.h b/sources/ui/autonumberingmanagementw.h new file mode 100644 index 000000000..ae0981c22 --- /dev/null +++ b/sources/ui/autonumberingmanagementw.h @@ -0,0 +1,63 @@ +/* + Copyright 2006-2016 The QElectroTech Team + This file is part of QElectroTech. + + QElectroTech 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. + + QElectroTech 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 QElectroTech. If not, see . +*/ +#ifndef AUTONUMBERINGMANAGEMENTW_H +#define AUTONUMBERINGMANAGEMENTW_H + +#include + +class NumPartEditorW; +class QAbstractButton; +class QETProject; + +namespace Ui { + class AutoNumberingManagementW; +} + +class AutoNumberingManagementW : public QWidget +{ + Q_OBJECT + + //METHODS + public: + explicit AutoNumberingManagementW(QETProject *project, QWidget *parent = 0); + ~AutoNumberingManagementW(); + Ui::AutoNumberingManagementW *ui; + void setProjectContext (); + void contextToFormula (); + QString elementFormula(); + + //SIGNALS + signals: + void applyPressed(); + + //SLOTS + private slots: + void on_m_from_folios_cb_currentIndexChanged(int); + void on_m_to_folios_cb_currentIndexChanged(int); + void on_m_status_cb_currentIndexChanged(int); + void on_m_apply_folios_rb_clicked(); + void on_m_apply_project_rb_clicked(); + void on_buttonBox_clicked(QAbstractButton *); + void applyEnable (bool = true); + + //ATTRIBUTES + private: + QETProject *project_; +}; + +#endif // AUTONUMBERINGMANAGEMENTW_H diff --git a/sources/ui/autonumberingmanagementw.ui b/sources/ui/autonumberingmanagementw.ui new file mode 100644 index 000000000..7f7c2bdc2 --- /dev/null +++ b/sources/ui/autonumberingmanagementw.ui @@ -0,0 +1,470 @@ + + + AutoNumberingManagementW + + + + 0 + 0 + 520 + 550 + + + + + 0 + 0 + + + + + 460 + 0 + + + + Form + + + + QLayout::SetDefaultConstraint + + + + + + 0 + 50 + + + + + 450 + 253 + + + + + 0 + 50 + + + + false + + + Qt::LeftToRight + + + Qt::ScrollBarAsNeeded + + + Qt::ScrollBarAlwaysOff + + + QAbstractScrollArea::AdjustToContents + + + true + + + Qt::AlignHCenter|Qt::AlignTop + + + + + 0 + 0 + 500 + 495 + + + + + 0 + 0 + + + + + 430 + 250 + + + + + QLayout::SetFixedSize + + + + + + 0 + 0 + + + + + 75 + true + + + + Project Status: + + + + + + + + 0 + 0 + + + + QComboBox::AdjustToContents + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + Range + + + + + + + + + + + + + Apply to Selected Locations + + + + + + + Apply to Selected Folios + + + + + + + Apply to Entire Project + + + + + + + + + + + + + + 0 + 0 + + + + From + + + + + + + + 0 + 0 + + + + + + + + + 0 + 0 + + + + To + + + + + + + + 0 + 0 + + + + + + + + + + + + + + Update Policy + + + + + + + + + + 75 + true + + + + Conductor + + + + + + + Only New + + + true + + + + + + + Existent and New + + + true + + + + + + + Both + + + true + + + + + + + Disable + + + + + + + + + + + 0 + 0 + + + + + + + + 75 + true + + + + Element + + + + + + + + 0 + 0 + + + + Both + + + true + + + + + + + + 0 + 0 + + + + Only New + + + true + + + + + + + + 0 + 0 + + + + Only Existent + + + true + + + + + + + + 0 + 0 + + + + Disable + + + + + + + + + + + 50 + false + true + + + + + + + + 75 + true + + + + Folio + + + + + + + Only New + + + true + + + + + + + Existent + + + true + + + + + + + Both + + + true + + + + + + + Disable + + + + + + + + + + + + + + + + + + 0 + 0 + + + + QDialogButtonBox::Apply|QDialogButtonBox::Help + + + + + + + + diff --git a/sources/ui/projectpropertiesdialog.cpp b/sources/ui/projectpropertiesdialog.cpp index 43855f126..c8152182f 100644 --- a/sources/ui/projectpropertiesdialog.cpp +++ b/sources/ui/projectpropertiesdialog.cpp @@ -71,6 +71,6 @@ void ProjectPropertiesDialog::setCurrentPage(ProjectPropertiesDialog::Page p) { * Change the current displayed tab to folio tab. */ void ProjectPropertiesDialog::changeToFolio() { - ProjectAutoNumConfigPage *autoNumPage = static_cast (m_properties_dialog->pages.at(2)); - autoNumPage->changeToTab(2); + ProjectAutoNumConfigPage *autoNumPage = static_cast (m_properties_dialog->pages.at(2)); + autoNumPage->changeToTab(3); }