kotschak/qelectrotech-source-mirror
0
0
Fork 0
mirror of https://github.com/qelectrotech/qelectrotech-source-mirror.git synced 2026-10-23 07:04:14 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

Tell the fields of a target apart by line breaks only

Browse Source 
A target typed in by hand was split into its fields on " / ", which
broke as soon as a field itself contained a slash: an installation
named "ASP/01" gave the box two lines with half a name in each, and
nothing to tell a separator apart from the name. Only a line break now
breaks the text into fields (RealTerminal::cableTarget()), and the
Target cell shows the fields the very same way, one line each
(modelRealTerminalData::targetText()), so the cell and the box under
the cable always read the same text.

The Target cell is edited line by line to go with that: it takes a
multi line editor where Return writes a new line, Ctrl+Return hands
the cell back to the table and Escape throws the text away
(TerminalStripModelDelegate), and the rows of the table are as tall as
the lines their cell shows, so the fields below the first one are never
cut off -- a cell without a target keeps the row it has always had.

The text copied to the clipboard keeps one line per row, the fields of
such a cell joined with " / " again, or a spreadsheet would take them
for several rows.

tst_terminalcableauto reads the three fields of a target of the
drawing back one line each, checks a "/" typed inside a field stays
part of it -- one line holding it, slashes and all -- checks the
editor of the cell is the multi line one, hands its text back
untouched, gives the cell back on Ctrl+Return while Return keeps
writing a new line, and checks the rows grow with the lines the cell
holds and shrink back afterwards. tst_cabletarget paints a strip whose
cable ends on a field containing a slash: the box is no deeper than
with one plain field.
This commit is contained in:
Kellermorph
2026-10-20 19:08:16 +02:00
parent 5baf5bec60
commit 36b1cb08ff
7 changed files with 342 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/qttest/tst_cabletarget.cpp
+26 -13
View File
@@ -51,9 +51,10 @@
Also here: the box at the end of a cable is written at the font of
the drawing -- the end zone the settings leave is what gives it the
room, so three lines never end up squeezed into a tiny text. A
target typed in by hand is written the way the fields are shown in
the column, "Installation / Location / Label", and the box draws one
line per field, with no slash in it. Two cables of one strip end
target typed in by hand is written one line per field, Installation,
Location, Label, the way the column shows them, and only a line
break breaks it into fields: a "/" written inside a field is part of
it, the box draws one line holding it. Two cables of one strip end
close to each other, and their boxes are wider than the room between
them: the box standing in the way of the other is set lower, its
stub drawn longer, and the strip reserves the room for it too.
@@ -529,12 +530,14 @@ void tst_cabletarget::realisticStyleDrawsTheCable()
}
/**
A target typed in by hand is written the way the fields are shown in
the column, "Installation / Location / Label": the box under the
cable draws one line per field, with no slash in it. The picture of
a strip whose cable ends on three fields is therefore that much
deeper than the picture of the same strip with one single field --
two lines of the font of the drawing.
A target typed in by hand is written one line per field, and only a
line break breaks it into fields: the box under the cable draws one
line per field, with no separator in it. The picture of a strip
whose cable ends on three fields is therefore that much deeper than
the picture of the same strip with one single field -- two lines of
the font of the drawing. A "/" written inside a field, an
installation named "Betrieb 1/2", keeps its line: the box is no
deeper than with one plain field.
*/
void tst_cabletarget::typedTargetIsDrawnInItsOwnLines()
{
@@ -604,9 +607,9 @@ void tst_cabletarget::typedTargetIsDrawnInItsOwnLines()
QVERIFY(one_line >= 0);
//Three fields: the box is two lines deeper, at the font of the
//drawing -- the slashes are only there to separate the fields in
//the column, the box never draws them
type_in(QStringLiteral("Boiler room / Cabinet 3 / -K3"));
//drawing -- the fields are written one under the other, the cell
//holding them only tells them apart by their line breaks
type_in(QStringLiteral("Boiler room\nCabinet 3\n-K3"));
QCOMPARE(a_->cableTarget(), (QVector<QString>{QStringLiteral("Boiler room"),
QStringLiteral("Cabinet 3"),
QStringLiteral("-K3")}));
@@ -614,6 +617,16 @@ void tst_cabletarget::typedTargetIsDrawnInItsOwnLines()
const QFontMetricsF metrics{pattern_->font()};
QVERIFY2(three_lines - one_line > 1.5 * metrics.height(),
"three fields must give a box two lines deeper than one field");
//A slash written inside a field is part of it: the text gives
//one single line, the box is back to the depth of one field and
//holds the slash where it was typed
type_in(QStringLiteral("Betrieb 1/2 / Keller"));
QCOMPARE(a_->cableTarget(),
QVector<QString>{QStringLiteral("Betrieb 1/2 / Keller")});
const qreal one_slashed_field{lowest_row(render())};
QVERIFY2(qAbs(one_slashed_field - one_line) < metrics.height() / 2,
"a slash inside a field must not split it into lines");
}
/**
@@ -688,7 +701,7 @@ void tst_cabletarget::boxesOfTwoCablesAreSetApart()
second_data_.m_informations.addValue(RealTerminal::cableInfoKey(),
QStringLiteral("X98"));
second_data_.m_informations.addValue(RealTerminal::cableTargetInfoKey(),
QStringLiteral("Plant 9 / Cabinet 9 / -S9"));
QStringLiteral("Plant 9\nCabinet 9\n-S9"));
second_->setElementData(second_data_);
QCOMPARE(b_->cableTarget(),
(QVector<QString>{QStringLiteral("Plant 9"),
tests/qttest/tst_terminalcableauto.cpp
+206 -17
View File
@@ -30,6 +30,12 @@
#include "qetproject.h"
#include <QAbstractItemView>
#include <QCoreApplication>
#include <QKeyEvent>
#include <QPlainTextEdit>
#include <QSignalSpy>
#include <QTableView>
#include <QTextCursor>
/**
The Cable and Color / wire number columns of the terminal strip editor
@@ -45,10 +51,11 @@
cable it is read only -- only the drawing decides it -- and with no
cable landing anywhere it is there to be typed in, just like the
Cable cell, the text then stored in the element and kept until a
cable works a target out again. A text typed in is written the way
the fields are shown in the column, "Installation / Location /
Label", so the box draws one line per field and not one long line
needing the slashes.
cable works a target out again. A text typed in is written one line
per field, Installation, Location, Label, the way the column shows
them: only a line break breaks it into fields, so a "/" written
inside a field (a name like "ASP/01") is part of that field and the
box draws one line containing it.
fixtures/every_feature.qet has the strip X1 whose two terminals are
wired to conductors on the folio, and no cable at all.
@@ -358,11 +365,11 @@ private slots:
QCOMPARE(model.data(model.index(0, TerminalStripModel::Cable))
.toString(), QStringLiteral("15W1"));
//The three fields, in the order the box draws them
//The three fields, one on its own line as the box draws them
const QModelIndex target_cell = model.index(0,
TerminalStripModel::CableTarget);
QCOMPARE(model.data(target_cell).toString(),
QStringLiteral("Plant 7 / Cabinet 7 / -S7"));
QStringLiteral("Plant 7\nCabinet 7\n-S7"));
QVERIFY(!(model.flags(target_cell) & Qt::ItemIsEditable));
QCOMPARE(model.headerData(TerminalStripModel::CableTarget,
Qt::Horizontal).toString(),
@@ -409,7 +416,7 @@ private slots:
QVERIFY(model->data(cell).toString().isEmpty());
QVERIFY(model->flags(cell) & Qt::ItemIsEditable);
const QString typed{QStringLiteral("Boiler room / Cabinet 3 / -K3")};
const QString typed{QStringLiteral("Boiler room\nCabinet 3\n-K3")};
QVERIFY(model->setData(cell, typed, Qt::EditRole));
QCOMPARE(model->data(cell, Qt::EditRole).toString(), typed);
QCOMPARE(model->data(cell).toString(), typed);
@@ -418,8 +425,8 @@ private slots:
editor.apply();
QCOMPARE(element->elementData().m_informations
.value(RealTerminal::cableTargetInfoKey()).toString(), typed);
//Three fields, written the way the column shows them: the box
//draws three lines, without the slashes
//Three lines, each field on its own: the box draws them one under
//the other, without any separator
QCOMPARE(real_t->cableTarget(),
(QVector<QString>{QStringLiteral("Boiler room"),
QStringLiteral("Cabinet 3"),
@@ -465,7 +472,7 @@ private slots:
const QModelIndex cable_cell = model_cable.index(
0, TerminalStripModel::CableTarget);
QCOMPARE(model_cable.data(cable_cell).toString(),
QStringLiteral("Plant 9 / Cabinet 9 / -S9"));
QStringLiteral("Plant 9\nCabinet 9\n-S9"));
QVERIFY(!(model_cable.flags(cable_cell) & Qt::ItemIsEditable));
//And the automatic target was never written in the element
QCOMPARE(element->elementData().m_informations
@@ -486,10 +493,11 @@ private slots:
QVERIFY(model_back.flags(back_cell) & Qt::ItemIsEditable);
}
// A text typed in by hand is written the way the fields are shown in
// the column, "Installation / Location / Label": the box under the
// cable draws one line per field, without the slashes, exactly like a
// target worked out from the project.
// A text typed in by hand is written one line per field, and only a
// line break breaks it into fields: the box under the cable draws
// one line per field, exactly like a target worked out from the
// project, while a "/" written inside a field is part of it and
// gives one single line holding it.
void typedTargetGivesOneLinePerField()
{
const QString fixture = QFINDTESTDATA("fixtures/every_feature.qet");
@@ -509,10 +517,11 @@ private slots:
QCOMPARE(real_t->cableTarget(),
QVector<QString>{QStringLiteral("Boiler room")});
//Three fields: three lines, and no slash anywhere in them
//Three fields, written one per line: three lines, and no
//separator anywhere in them
typed = element->elementData();
typed.m_informations.addValue(RealTerminal::cableTargetInfoKey(),
QStringLiteral("Plant 9 / Cabinet 9 / -S9"));
QStringLiteral("Plant 9\nCabinet 9\n-S9"));
element->setElementData(typed);
QCOMPARE(real_t->cableTarget(),
(QVector<QString>{QStringLiteral("Plant 9"),
@@ -524,7 +533,187 @@ private slots:
//The column shows the text back the way it was written
TerminalStripModel model(project.terminalStrip().first());
QCOMPARE(model.data(model.index(0, TerminalStripModel::CableTarget))
.toString(), QStringLiteral("Plant 9 / Cabinet 9 / -S9"));
.toString(), QStringLiteral("Plant 9\nCabinet 9\n-S9"));
//A slash inside a field, and one typed between two words of a
//field kept in one line: both stay part of the field, the cell
//shows them untouched and the box holds one single line each
typed = element->elementData();
typed.m_informations.addValue(RealTerminal::cableTargetInfoKey(),
QStringLiteral("Betrieb 1/2"));
element->setElementData(typed);
QCOMPARE(real_t->cableTarget(),
QVector<QString>{QStringLiteral("Betrieb 1/2")});
typed = element->elementData();
typed.m_informations.addValue(RealTerminal::cableTargetInfoKey(),
QStringLiteral("Betrieb 1/2 / Keller"));
element->setElementData(typed);
QCOMPARE(real_t->cableTarget(),
QVector<QString>{QStringLiteral("Betrieb 1/2 / Keller")});
TerminalStripModel slashed(project.terminalStrip().first());
QCOMPARE(slashed.data(slashed.index(0, TerminalStripModel::CableTarget))
.toString(), QStringLiteral("Betrieb 1/2 / Keller"));
//The line breaks written by hand are the fields again, whatever
//the fields themselves contain
typed = element->elementData();
typed.m_informations.addValue(RealTerminal::cableTargetInfoKey(),
QStringLiteral("Betrieb 1/2\nKeller\n-K4"));
element->setElementData(typed);
QCOMPARE(real_t->cableTarget(),
(QVector<QString>{QStringLiteral("Betrieb 1/2"),
QStringLiteral("Keller"),
QStringLiteral("-K4")}));
}
// The Target cell is edited line by line: its editor holds one line
// per field and hands the text back exactly as the cell holds it.
// Return writes a new line (the cell is multi line), Ctrl+Return
// gives the cell back without waiting for the focus to go somewhere
// else, and the row of the table is as tall as the lines the cell
// shows, so none of them is cut off.
void targetCellIsEditedLineByLine()
{
const QString fixture = QFINDTESTDATA("fixtures/every_feature.qet");
QETProject project(fixture);
QCOMPARE(project.state(), QETProject::Ok);
TerminalStripEditor editor(&project);
editor.setCurrentStrip(project.terminalStrip().first());
QTableView *table = editor.findChild<QTableView *>(
QStringLiteral("m_table_widget"));
QVERIFY2(table && table->model(), "the editor has its table");
QAbstractItemModel *model = table->model();
QVERIFY(model->rowCount() > 1);
const QModelIndex cell = model->index(0, TerminalStripModel::CableTarget);
QVERIFY(model->flags(cell) & Qt::ItemIsEditable);
const QString typed{QStringLiteral("Betrieb 1/2\nKeller\n-K4")};
QVERIFY(model->setData(cell, typed, Qt::EditRole));
QCOMPARE(model->data(cell).toString(), typed);
//The editor of the table is the one taking a cell of several
//lines, and one of its own does the very same thing for the
//keys, without a view in between
QVERIFY(qobject_cast<TerminalStripModelDelegate *>(
table->itemDelegate()));
TerminalStripModelDelegate delegate;
QStyleOptionViewItem option;
option.rect = QRect(0, 0, qMax(
50, table->columnWidth(TerminalStripModel::CableTarget)), 400);
option.font = table->font();
option.fontMetrics = QFontMetrics(option.font);
QWidget *cell_editor = delegate.createEditor(table, option, cell);
QVERIFY(cell_editor);
auto *text_edit = qobject_cast<QPlainTextEdit *>(cell_editor);
QVERIFY2(text_edit, "the Target cell takes a multi line editor");
QCOMPARE(text_edit->objectName(),
QStringLiteral("terminal_cable_target"));
//The editor gives the lines back exactly as the cell holds
//them: nothing joined, nothing split again
delegate.setEditorData(cell_editor, cell);
QCOMPARE(text_edit->toPlainText(), typed);
delegate.setModelData(cell_editor, model, cell);
QCOMPARE(model->data(cell).toString(), typed);
//Return writes a new line in the cell, and hands nothing over
//yet: Ctrl+Return is the key giving the cell back
QSignalSpy committed(&delegate, &TerminalStripModelDelegate::commitData);
QSignalSpy closed(&delegate, &TerminalStripModelDelegate::closeEditor);
text_edit->moveCursor(QTextCursor::End);
QKeyEvent return_key{QEvent::KeyPress, Qt::Key_Return,
Qt::NoModifier};
QCoreApplication::sendEvent(cell_editor, &return_key);
QCOMPARE(text_edit->toPlainText(), typed + QLatin1Char('\n'));
QCOMPARE(committed.count(), 0);
QCOMPARE(closed.count(), 0);
QKeyEvent ctrl_return_key{QEvent::KeyPress, Qt::Key_Return,
Qt::ControlModifier};
QCoreApplication::sendEvent(cell_editor, &ctrl_return_key);
QCOMPARE(committed.count(), 1);
QCOMPARE(closed.count(), 1);
delete cell_editor;
}
// The row of the table follows the lines its Target cell holds: the
// cell is never cut off, however many lines it takes, the row grows
// to hold them all and shrinks back afterwards, while the rows
// around keep the height they have always had.
void targetRowGrowsWithTheLinesOfItsCell()
{
const QString fixture = QFINDTESTDATA("fixtures/every_feature.qet");
QETProject project(fixture);
QCOMPARE(project.state(), QETProject::Ok);
TerminalStripEditor editor(&project);
editor.setCurrentStrip(project.terminalStrip().first());
QTableView *table = editor.findChild<QTableView *>(
QStringLiteral("m_table_widget"));
QVERIFY2(table && table->model(), "the editor has its table");
QAbstractItemModel *model = table->model();
QVERIFY(model->rowCount() > 1);
const QModelIndex cell = model->index(0, TerminalStripModel::CableTarget);
QVERIFY(model->flags(cell) & Qt::ItemIsEditable);
QVERIFY2(model->data(cell).toString().isEmpty(),
"no target to start with, the row is the usual one");
const QModelIndex other_cell = model->index(
1, TerminalStripModel::CableTarget);
const int base_row = table->rowHeight(cell.row());
const int base_other_row = table->rowHeight(other_cell.row());
QVERIFY(base_row > 0);
//Three lines in the cell: the row holds them all, at the
//font of the table -- the row was already taller than that
//for what else the terminal draws, so it may stay as it is
const QString typed{QStringLiteral("Betrieb 1/2\nKeller\n-K4")};
QVERIFY(model->setData(cell, typed, Qt::EditRole));
QCOMPARE(model->data(cell).toString(), typed);
const auto heightOfLines = [table](int lines_) {
return lines_ * table->fontMetrics().height();
};
const int three_line_row = table->rowHeight(cell.row());
QVERIFY2(three_line_row >= qMax(base_row, heightOfLines(3)),
"the row must be as tall as both the lines the cell "
"shows and what it held before, or something is cut off");
QVERIFY2(table->rowHeight(other_cell.row()) >= base_other_row,
"the rows around are not pushed down");
//From here on the rows have been worked out once: what the
//other rows hold is the height they keep
const int other_row = table->rowHeight(other_cell.row());
//Many more lines than anything else in the row: the row grows
//to hold them, and the rows around stay where they are
const QString many{QStringLiteral(
"Plant 6\nCabinet 6\n-K6\nZone 6\nLevel 6\nEnd 6")};
QVERIFY(model->setData(cell, many, Qt::EditRole));
const int six_line_row = table->rowHeight(cell.row());
QVERIFY2(six_line_row >= heightOfLines(6),
"the row must be as tall as the lines the cell shows, "
"or the fields below the first one are cut off");
QVERIFY2(six_line_row > qMax(base_row, three_line_row),
"a cell which took six lines must take a taller row "
"than the one it had before");
QVERIFY2(table->rowHeight(other_cell.row()) == other_row,
"the rows around keep their own height");
//Back to one single line: the row follows again
QVERIFY(model->setData(cell, QStringLiteral("Keller"), Qt::EditRole));
QVERIFY2(table->rowHeight(cell.row()) < six_line_row,
"the row follows the cell back to a single line");
QVERIFY2(table->rowHeight(cell.row())
<= base_row + table->fontMetrics().height(),
"the row is back to the height it had before");
QVERIFY2(table->rowHeight(cell.row()) >= table->fontMetrics().height(),
"the single line left is still shown");
}
};