mirror of
https://github.com/qelectrotech/qelectrotech-source-mirror.git
synced 2026-08-03 18:44:13 +02:00
ispyisail
68e75b4c55
PotentialSelectorDialog::chosenProperties() built an OK-only dialog
and discarded exec()'s return value entirely:
dialog.exec();
for (QRadioButton *b : H.keys()) {
if (b->isChecked()) return H.value(b);
}
return ConductorProperties();
Escape and the window close button already trigger QDialog::reject()
on a plain QDialog, but since the result was never checked, dismissing
the dialog without picking anything just silently returned blank
ConductorProperties() -- the same value returned when a real potential
was chosen but happened to produce empty properties. There was no way
to distinguish "the user cancelled" from "the user chose an empty
potential", so the caller always proceeded as if a choice had been
made.
Add a real Cancel button, check dialog.exec() == QDialog::Accepted,
and report cancellation through a new optional `bool *cancelled`
out-parameter. Also pre-select the first entry, closing a related gap
where clicking OK without ever touching a radio button hit the exact
same "silently returns blank properties" failure mode.
Thread the result through ConductorCreator::setUpPropertieToUse()
(now returning bool) so the calling constructor aborts and creates no
conductors at all when the user cancels, instead of proceeding with
blank properties.
The sibling constructor-based PotentialSelectorDialog (used for
conductor/report potential linking, a separate flow) already gates its
side effects behind on_buttonBox_accepted(), so cancelling it was
already safe -- gave it a visible Cancel button too for consistency
while touching this file, no behavior change there.
Verified with real Qt event simulation (QTest::mouseClick/keyClick)
against the exact new dialog-building logic: clicking Cancel and
pressing Escape both correctly report cancellation with empty
properties; clicking OK untouched returns the pre-selected first
entry; selecting the second option then OK returns that selection.
See discussion #581.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
574 lines
17 KiB
C++
574 lines
17 KiB
C++
/*
|
|
Copyright 2006-2026 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 <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "potentialselectordialog.h"
|
|
|
|
#include "../QPropertyUndoCommand/qpropertyundocommand.h"
|
|
#include "../autoNum/assignvariables.h"
|
|
#include "../diagram.h"
|
|
#include "../qetgraphicsitem/conductor.h"
|
|
#include "../qetgraphicsitem/element.h"
|
|
#include "../qetgraphicsitem/reportelement.h"
|
|
#include "../qetgraphicsitem/terminal.h"
|
|
#include "../ui_potentialselectordialog.h"
|
|
#include "formulaassistantdialog.h"
|
|
|
|
#include <QHash>
|
|
#include <QRadioButton>
|
|
|
|
//### BEGIN PRIVATE CLASS ###//
|
|
|
|
/**
|
|
@brief The NewConductorPotentialSelector class
|
|
Used for getting the conductor properties when two potentials are linked by a conductor
|
|
*/
|
|
class NewConductorPotentialSelector : public AbstractPotentialSelector
|
|
{
|
|
public:
|
|
NewConductorPotentialSelector(Conductor *conductor) :
|
|
m_is_valid(false)
|
|
{
|
|
Terminal *terminal_1 = conductor->terminal1;
|
|
Terminal *terminal_2 = conductor->terminal2;
|
|
//We temporarily remove the conductor of its two terminals,
|
|
//to get the two existing potential
|
|
terminal_1->removeConductor(conductor);
|
|
terminal_2->removeConductor(conductor);
|
|
|
|
getPotential(terminal_1,
|
|
m_seq_num_1,
|
|
m_conductor_number_1,
|
|
m_properties_list_1,
|
|
m_conductors_list_1);
|
|
getPotential(terminal_2,
|
|
m_seq_num_2,
|
|
m_conductor_number_2,
|
|
m_properties_list_2,
|
|
m_conductors_list_2);
|
|
|
|
//There isn't a potential at terminal 1 or 2.
|
|
if (m_conductor_number_1 == 0
|
|
&& m_conductor_number_2 == 0) return;
|
|
|
|
//Re-add conductor to his terminals.
|
|
terminal_1->addConductor(conductor);
|
|
terminal_2->addConductor(conductor);
|
|
m_is_valid = true;
|
|
}
|
|
|
|
bool isValid() const override {return m_is_valid;}
|
|
|
|
/**
|
|
@brief getPotential
|
|
Get the conductor properties of the potential at terminal,
|
|
and the number of wire in this potential.
|
|
@param terminal
|
|
@param seq_num
|
|
@param number
|
|
@param properties_list
|
|
@param c_list
|
|
*/
|
|
void getPotential(
|
|
Terminal *terminal,
|
|
autonum::sequentialNumbers &seq_num ,
|
|
int &number, QList<ConductorProperties> &properties_list,
|
|
QList<Conductor*> &c_list)
|
|
{
|
|
Conductor *conductor_in_potential = nullptr;
|
|
|
|
//Terminal have conductor linked to, we get it.
|
|
if (!terminal->conductors().isEmpty())
|
|
conductor_in_potential = terminal->conductors().first();
|
|
|
|
//Terminal haven't got a conductor, but if parent element is a folio report or a terminal element, we search a potential
|
|
//through the report or in another terminal of the terminal element.
|
|
else if (terminal->parentElement()->linkType() & (Element::Terminale | Element::AllReport))
|
|
{
|
|
Element *elmt_ = terminal->parentElement();
|
|
|
|
if ((elmt_->linkType() & Element::Terminale) && !elmt_->terminals().isEmpty())
|
|
{
|
|
foreach(Terminal *t, elmt_->terminals())
|
|
{
|
|
if (t->conductors().isEmpty()) continue;
|
|
conductor_in_potential = t->conductors().first();
|
|
break;
|
|
}
|
|
}
|
|
else if ((elmt_->linkType() & Element::AllReport) && !elmt_->isFree())
|
|
{
|
|
Element *other_report = elmt_->linkedElements().first();
|
|
if (other_report->terminals().isEmpty()) return;
|
|
Terminal *t = other_report->terminals().first();
|
|
if (t->conductors().isEmpty()) return;
|
|
conductor_in_potential= t->conductors().first();
|
|
}
|
|
}
|
|
|
|
if (!conductor_in_potential)
|
|
return;
|
|
seq_num = conductor_in_potential->sequenceNum();
|
|
//We add +1 because conductor_in_potential isn't count by relatedPotentialConductors
|
|
number = conductor_in_potential->relatedPotentialConductors().size()+1;
|
|
|
|
c_list = conductor_in_potential->relatedPotentialConductors().values();
|
|
c_list.append(conductor_in_potential);
|
|
foreach(Conductor *c, c_list)
|
|
properties_list.append(c->properties());
|
|
}
|
|
|
|
~NewConductorPotentialSelector() override {}
|
|
|
|
private :
|
|
bool m_is_valid;
|
|
};
|
|
|
|
/**
|
|
@brief The LinkReportPotentialSelector class
|
|
Use for getting the conductor properties when two potentials are linked with a folio report
|
|
*/
|
|
class LinkReportPotentialSelector : public AbstractPotentialSelector
|
|
{
|
|
public:
|
|
LinkReportPotentialSelector(Element *report) :
|
|
m_is_valid(false)
|
|
{
|
|
if ((report->linkType() & Element::AllReport) && !report->isFree())
|
|
{
|
|
//We temporarily unlink report to get the two existing potential
|
|
Element *other_report = report->linkedElements().first();
|
|
report->unlinkAllElements();
|
|
|
|
if (report->conductors().isEmpty() || other_report->conductors().isEmpty())
|
|
return;
|
|
|
|
m_conductor_number_1 = report->conductors().first()->relatedPotentialConductors().size() + 1;
|
|
m_seq_num_1 = report->conductors().first()->sequenceNum();
|
|
m_conductors_list_1.append(report->conductors().first()->relatedPotentialConductors().values());
|
|
m_conductors_list_1.append(report->conductors().first());
|
|
foreach(Conductor *c, m_conductors_list_1)
|
|
m_properties_list_1 << c->properties();
|
|
|
|
m_conductor_number_2 = other_report->conductors().first()->relatedPotentialConductors().size() + 1;
|
|
m_seq_num_2 = other_report->conductors().first()->sequenceNum();
|
|
m_conductors_list_2.append(other_report->conductors().first()->relatedPotentialConductors().values());
|
|
m_conductors_list_2.append(other_report->conductors().first());
|
|
foreach(Conductor *c, m_conductors_list_2)
|
|
m_properties_list_2 << c->properties();
|
|
|
|
//We relink the report
|
|
report->linkToElement(other_report);
|
|
m_is_valid = true;
|
|
}
|
|
}
|
|
|
|
~LinkReportPotentialSelector() override {}
|
|
|
|
bool isValid() const override {return m_is_valid;}
|
|
|
|
private:
|
|
bool m_is_valid;
|
|
};
|
|
|
|
//### END PRIVATE CLASS ###//
|
|
|
|
|
|
ConductorProperties PotentialSelectorDialog::chosenProperties(QList<ConductorProperties> list, QWidget *widget, bool *cancelled)
|
|
{
|
|
if (cancelled)
|
|
*cancelled = false;
|
|
|
|
if (list.isEmpty()) {
|
|
return ConductorProperties() ;
|
|
} else if (list.size() == 1) {
|
|
return list.first();
|
|
}
|
|
|
|
QDialog dialog(widget);
|
|
QVBoxLayout layout(widget);
|
|
dialog.setLayout(&layout);
|
|
QLabel label(tr("Veuillez choisir un potentiel électrique de la liste \n"
|
|
"à utiliser pour le nouveau potentiel"));
|
|
layout.addWidget(&label);
|
|
|
|
QHash <QRadioButton *, ConductorProperties> H;
|
|
for (ConductorProperties cp : list)
|
|
{
|
|
QString text;
|
|
if(!cp.text.isEmpty())
|
|
text.append(tr("\nNuméro : %1").arg(cp.text));
|
|
if(!cp.m_function.isEmpty())
|
|
text.append(tr("\nFonction : %1").arg(cp.m_function));
|
|
if(!cp.m_tension_protocol.isEmpty())
|
|
text.append(tr("\nTension/protocole : %1").arg(cp.m_tension_protocol));
|
|
if(!cp.m_wire_color.isEmpty())
|
|
text.append(tr("\nCouleur du conducteur : %1").arg(cp.m_wire_color));
|
|
if(!cp.m_wire_section.isEmpty())
|
|
text.append(tr("\nSection du conducteur : %1").arg(cp.m_wire_section));
|
|
|
|
QRadioButton *b = new QRadioButton(text, &dialog);
|
|
layout.addWidget(b);
|
|
H.insert(b, cp);
|
|
}
|
|
|
|
// Pre-select the first entry: without this, accepting the dialog without
|
|
// ever touching a radio button silently returned blank properties too,
|
|
// the same failure mode as the missing Cancel button below.
|
|
if (!H.isEmpty())
|
|
H.constBegin().key()->setChecked(true);
|
|
|
|
QDialogButtonBox *button_box = new QDialogButtonBox(
|
|
QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dialog);
|
|
layout.addWidget(button_box);
|
|
connect(button_box, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
|
|
connect(button_box, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
|
|
|
|
if (dialog.exec() != QDialog::Accepted) {
|
|
if (cancelled)
|
|
*cancelled = true;
|
|
return ConductorProperties();
|
|
}
|
|
|
|
for (QRadioButton *b : H.keys()) {
|
|
if(b->isChecked()) {
|
|
return H.value(b);
|
|
}
|
|
}
|
|
|
|
return ConductorProperties();
|
|
}
|
|
|
|
/**
|
|
@brief PotentialSelectorDialog::PotentialSelectorDialog
|
|
Constructor when we link two potentiels together, with a conductor
|
|
@param conductor : the new conductor who connect to existing potential
|
|
@param parent_undo : undo parent to use.
|
|
@param parent : parent widget.
|
|
*/
|
|
PotentialSelectorDialog::PotentialSelectorDialog(Conductor *conductor,
|
|
QUndoCommand *parent_undo,
|
|
QWidget *parent) :
|
|
QDialog(parent),
|
|
ui(new Ui::PotentialSelectorDialog),
|
|
m_conductor(conductor),
|
|
m_report(nullptr),
|
|
m_parent_undo(parent_undo)
|
|
{
|
|
ui->setupUi(this);
|
|
m_potential_selector = new NewConductorPotentialSelector(conductor);
|
|
buildWidget();
|
|
}
|
|
|
|
/**
|
|
@brief PotentialSelectorDialog::PotentialSelectorDialog
|
|
Constructor when we link two potentiels together, with a folio report.
|
|
@param report : one of the report used to link the potentials
|
|
(report must be linked to another report)
|
|
@param parent_undo : undo parent to use
|
|
@param parent : parent widget
|
|
*/
|
|
PotentialSelectorDialog::PotentialSelectorDialog(Element *report,
|
|
QUndoCommand *parent_undo,
|
|
QWidget *parent) :
|
|
QDialog(parent),
|
|
ui(new Ui::PotentialSelectorDialog),
|
|
m_conductor(nullptr),
|
|
m_report(report),
|
|
m_parent_undo(parent_undo)
|
|
{
|
|
ui->setupUi(this);
|
|
m_potential_selector = new LinkReportPotentialSelector(report);
|
|
buildWidget();
|
|
}
|
|
|
|
PotentialSelectorDialog::~PotentialSelectorDialog()
|
|
{
|
|
delete ui;
|
|
delete m_potential_selector;
|
|
}
|
|
|
|
/**
|
|
@brief PotentialSelectorDialog::buildWidget
|
|
Build the dialog
|
|
*/
|
|
void PotentialSelectorDialog::buildWidget()
|
|
{
|
|
QString text1(tr("%n conducteurs composent le potentiel suivant :",
|
|
"",
|
|
m_potential_selector->m_conductor_number_1));
|
|
|
|
ConductorProperties cp1;
|
|
if(!m_potential_selector->m_properties_list_1.isEmpty())
|
|
cp1 = m_potential_selector->m_properties_list_1.first();;
|
|
|
|
if(!cp1.text.isEmpty())
|
|
text1.append(tr("\nNuméro : %1").arg(cp1.text));
|
|
if(!cp1.m_function.isEmpty())
|
|
text1.append(tr("\nFonction : %1").arg(cp1.m_function));
|
|
if(!cp1.m_tension_protocol.isEmpty())
|
|
text1.append(tr("\nTension/protocole : %1")
|
|
.arg(cp1.m_tension_protocol));
|
|
if(!cp1.m_wire_color.isEmpty())
|
|
text1.append(tr("\nCouleur du conducteur : %1")
|
|
.arg(cp1.m_wire_color));
|
|
if(!cp1.m_wire_section.isEmpty())
|
|
text1.append(tr("\nSection du conducteur : %1")
|
|
.arg(cp1.m_wire_section));
|
|
|
|
QString text2(tr("%n conducteurs composent le potentiel suivant :",
|
|
"",
|
|
m_potential_selector->m_conductor_number_2));
|
|
ConductorProperties cp2;
|
|
if(!m_potential_selector->m_properties_list_2.isEmpty())
|
|
cp2 = m_potential_selector->m_properties_list_2.first();
|
|
|
|
if(!cp2.text.isEmpty())
|
|
text2.append(tr("\nNuméro : %1").arg(cp2.text));
|
|
if(!cp2.m_function.isEmpty())
|
|
text2.append(tr("\nFonction : %1").arg(cp2.m_function));
|
|
if(!cp2.m_tension_protocol.isEmpty())
|
|
text2.append(tr("\nTension/protocole : %1")
|
|
.arg(cp2.m_tension_protocol));
|
|
if(!cp2.m_wire_color.isEmpty())
|
|
text2.append(tr("\nCouleur du conducteur : %1")
|
|
.arg(cp2.m_wire_color));
|
|
if(!cp2.m_wire_section.isEmpty())
|
|
text2.append(tr("\nSection du conducteur : %1")
|
|
.arg(cp2.m_wire_section));
|
|
|
|
QRadioButton *rb1 = new QRadioButton(text1, this);
|
|
QRadioButton *rb2 = new QRadioButton(text2, this);
|
|
|
|
QRadioButton *rbk = new QRadioButton(
|
|
tr("Ajouter au câble: %1")
|
|
.arg("wouldn't this be nice?"), this);
|
|
QRadioButton *rbb = new QRadioButton(
|
|
tr("Ajouter au bus: %1")
|
|
.arg("wouldn't this be nice?"), this);
|
|
|
|
#if TODO_LIST
|
|
#pragma message("@TODO Add Kabel and Bus to qet")
|
|
#else
|
|
rbk->setDisabled(true);
|
|
rbb->setDisabled(true);
|
|
#endif
|
|
connect(rb1, &QRadioButton::toggled, [this](bool t)
|
|
{
|
|
if(t)
|
|
{
|
|
this->m_sequential_num =
|
|
this->m_potential_selector->m_seq_num_1;
|
|
this->m_properties_list =
|
|
this->m_potential_selector
|
|
->m_properties_list_1;
|
|
this->m_conductors_to_change =
|
|
this->m_potential_selector
|
|
->m_conductors_list_2;
|
|
}
|
|
});
|
|
connect(rb2, &QRadioButton::toggled, [this](bool t)
|
|
{
|
|
if(t)
|
|
{
|
|
this->m_sequential_num =
|
|
this->m_potential_selector->m_seq_num_2;
|
|
this->m_properties_list =
|
|
this->m_potential_selector
|
|
->m_properties_list_2;
|
|
this->m_conductors_to_change =
|
|
this->m_potential_selector
|
|
->m_conductors_list_1;
|
|
}
|
|
});
|
|
|
|
//Set the radio button of potential with the bigger number of conductors,
|
|
//at first position, and check it
|
|
if (m_potential_selector->m_conductor_number_1 >=
|
|
m_potential_selector->m_conductor_number_2)
|
|
{
|
|
ui->verticalLayout->insertWidget(1, rb1);
|
|
ui->verticalLayout->insertWidget(2, rb2);
|
|
rb1->setChecked(true);
|
|
}
|
|
else
|
|
{
|
|
ui->verticalLayout->insertWidget(1, rb2);
|
|
ui->verticalLayout->insertWidget(2, rb1);
|
|
rb2->setChecked(true);
|
|
}
|
|
|
|
ui->verticalLayout->insertWidget(3, rbk);
|
|
ui->verticalLayout->insertWidget(4, rbb);
|
|
}
|
|
|
|
/**
|
|
@brief PotentialSelectorDialog::on_buttonBox_accepted
|
|
Action when user click on OK button
|
|
*/
|
|
void PotentialSelectorDialog::on_buttonBox_accepted()
|
|
{
|
|
if (!m_potential_selector->isValid())
|
|
return;
|
|
|
|
QUndoCommand *undo = nullptr;
|
|
if (m_parent_undo)
|
|
undo = m_parent_undo;
|
|
else
|
|
undo = new QUndoCommand(
|
|
tr("Modifier les propriétés de plusieurs conducteurs",
|
|
"undo caption"));
|
|
|
|
Diagram * diagram = nullptr;
|
|
|
|
if (m_report)
|
|
{
|
|
if ((m_report->linkType() & Element::AllReport)
|
|
&& !m_report->isFree())
|
|
{
|
|
if (m_report->diagram())
|
|
diagram = m_report->diagram();
|
|
|
|
QVariant old_value, new_value;
|
|
QVariant old_seq, new_seq;
|
|
new_seq.setValue(m_sequential_num);
|
|
|
|
//Set the new properties for each conductors of the new potential
|
|
foreach(Conductor *cond, m_conductors_to_change)
|
|
{
|
|
ConductorProperties new_properties = cond->properties();
|
|
new_properties.applyForEqualAttributes(m_properties_list);
|
|
old_value.setValue(cond->properties());
|
|
new_value.setValue(new_properties);
|
|
old_seq.setValue(cond->sequenceNum());
|
|
new QPropertyUndoCommand(cond,
|
|
"sequenceNum",
|
|
old_seq,
|
|
new_seq,
|
|
undo);
|
|
new QPropertyUndoCommand(cond,
|
|
"properties",
|
|
old_value,
|
|
new_value,
|
|
undo);
|
|
}
|
|
|
|
//Check if formula of the new potential
|
|
// have incompatible variable with folio report
|
|
QRegularExpression rx ("%sequf_|%seqtf_|%seqhf_|%id|%F|%M|%LM");
|
|
foreach(ConductorProperties cp, m_properties_list)
|
|
{
|
|
if (cp.m_formula.contains(rx))
|
|
{
|
|
QStringList forbidden_str;
|
|
forbidden_str << "%sequf_"
|
|
<< "%seqtf_"
|
|
<< "%seqhf_"
|
|
<< "%id"
|
|
<< "%F"
|
|
<< "%M"
|
|
<< "%LM";
|
|
|
|
QString text(tr("La formule du nouveau potentiel contient des variables incompatibles avec les reports de folio.\n"
|
|
"Veuillez saisir une formule compatible pour ce potentiel.\n"
|
|
"Les variables suivantes sont incompatibles :\n"
|
|
"%sequf_ %seqtf_ %seqhf_ %id %F %M %LM"));
|
|
FormulaAssistantDialog fag(this);
|
|
fag.setForbiddenVariables(forbidden_str);
|
|
fag.setText(text);
|
|
fag.setFormula(cp.m_formula);
|
|
fag.exec();
|
|
|
|
QString new_formula = fag.formula();
|
|
QSet <Conductor *> c_list = m_report->conductors().first()->relatedPotentialConductors();
|
|
c_list.insert(m_report->conductors().first());
|
|
foreach(Conductor *cond, c_list)
|
|
{
|
|
old_value.setValue(cond->properties());
|
|
ConductorProperties new_properties = cond->properties();
|
|
new_properties.m_formula = new_formula;
|
|
new_value.setValue(new_properties);
|
|
new QPropertyUndoCommand(cond,
|
|
"properties",
|
|
old_value,
|
|
new_value,
|
|
undo);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
else if (m_conductor)
|
|
{
|
|
if (m_conductor->diagram())
|
|
diagram = m_conductor->diagram();
|
|
|
|
ConductorProperties new_properties = m_conductor->properties();
|
|
new_properties.applyForEqualAttributes(m_properties_list);
|
|
|
|
QVariant old_value, new_value;
|
|
old_value.setValue(m_conductor->properties());
|
|
new_value.setValue(new_properties);
|
|
|
|
QVariant old_seq, new_seq;
|
|
old_seq.setValue(m_conductor->sequenceNum());
|
|
new_seq.setValue(m_sequential_num);
|
|
|
|
new QPropertyUndoCommand(m_conductor,
|
|
"sequenceNum",
|
|
old_seq,
|
|
new_seq,
|
|
undo);
|
|
new QPropertyUndoCommand(m_conductor,
|
|
"properties",
|
|
old_value,
|
|
new_value,
|
|
undo);
|
|
|
|
//Set the new properties for each conductors of the new potential
|
|
foreach(Conductor *cond, m_conductor->relatedPotentialConductors())
|
|
{
|
|
new_properties = cond->properties();
|
|
new_properties.applyForEqualAttributes(m_properties_list);
|
|
old_value.setValue(cond->properties());
|
|
new_value.setValue(new_properties);
|
|
old_seq.setValue(cond->sequenceNum());
|
|
new QPropertyUndoCommand(cond,
|
|
"sequenceNum",
|
|
old_seq,
|
|
new_seq,
|
|
undo);
|
|
new QPropertyUndoCommand(cond,
|
|
"properties",
|
|
old_value,
|
|
new_value,
|
|
undo);
|
|
}
|
|
}
|
|
|
|
//There is an undo parent, we stop here,
|
|
//the owner of m_parent_undo will push it to an undo stack
|
|
if (m_parent_undo)
|
|
return;
|
|
//There isn't a parent, we push the undo command to diagram undo stack.
|
|
if (diagram)
|
|
diagram->undoStack().push(undo);
|
|
}
|